<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE LambdaCase #-}</span><span>
</span><span id="line-2"></span><span>
</span><span id="line-3"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">GHC.Builtin.Types.Literals</span><span>
</span><span id="line-4"></span><span>  </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatTyCons"><span class="hs-identifier">typeNatTyCons</span></a></span><span>
</span><span id="line-5"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatCoAxiomRules"><span class="hs-identifier">typeNatCoAxiomRules</span></a></span><span>
</span><span id="line-6"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier">BuiltInSynFamily</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-7"></span><span>
</span><span id="line-8"></span><span>    </span><span class="hs-comment">-- If you define a new built-in type family, make sure to export its TyCon</span><span>
</span><span id="line-9"></span><span>    </span><span class="hs-comment">-- from here as well.</span><span>
</span><span id="line-10"></span><span>    </span><span class="hs-comment">-- See Note [Adding built-in type families]</span><span>
</span><span id="line-11"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatAddTyCon"><span class="hs-identifier">typeNatAddTyCon</span></a></span><span>
</span><span id="line-12"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatMulTyCon"><span class="hs-identifier">typeNatMulTyCon</span></a></span><span>
</span><span id="line-13"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatExpTyCon"><span class="hs-identifier">typeNatExpTyCon</span></a></span><span>
</span><span id="line-14"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatLeqTyCon"><span class="hs-identifier">typeNatLeqTyCon</span></a></span><span>
</span><span id="line-15"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatSubTyCon"><span class="hs-identifier">typeNatSubTyCon</span></a></span><span>
</span><span id="line-16"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatDivTyCon"><span class="hs-identifier">typeNatDivTyCon</span></a></span><span>
</span><span id="line-17"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatModTyCon"><span class="hs-identifier">typeNatModTyCon</span></a></span><span>
</span><span id="line-18"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatLogTyCon"><span class="hs-identifier">typeNatLogTyCon</span></a></span><span>
</span><span id="line-19"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatCmpTyCon"><span class="hs-identifier">typeNatCmpTyCon</span></a></span><span>
</span><span id="line-20"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeSymbolCmpTyCon"><span class="hs-identifier">typeSymbolCmpTyCon</span></a></span><span>
</span><span id="line-21"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeSymbolAppendTyCon"><span class="hs-identifier">typeSymbolAppendTyCon</span></a></span><span>
</span><span id="line-22"></span><span>  </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-23"></span><span>
</span><span id="line-24"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Prelude.html"><span class="hs-identifier">GHC.Prelude</span></a></span><span>
</span><span id="line-25"></span><span>
</span><span id="line-26"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Core.Type.html"><span class="hs-identifier">GHC.Core.Type</span></a></span><span>
</span><span id="line-27"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Data.Pair.html"><span class="hs-identifier">GHC.Data.Pair</span></a></span><span>
</span><span id="line-28"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Tc.Utils.TcType.html"><span class="hs-identifier">GHC.Tc.Utils.TcType</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="GHC.Tc.Utils.TcType.html#TcType"><span class="hs-identifier">TcType</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier">tcEqType</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-29"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html"><span class="hs-identifier">GHC.Core.TyCon</span></a></span><span>    </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier">TyCon</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#FamTyConFlav"><span class="hs-identifier">FamTyConFlav</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#mkFamilyTyCon"><span class="hs-identifier">mkFamilyTyCon</span></a></span><span>
</span><span id="line-30"></span><span>                         </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#Injectivity"><span class="hs-identifier">Injectivity</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-31"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.html"><span class="hs-identifier">GHC.Core.Coercion</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#Role"><span class="hs-identifier">Role</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-32"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html"><span class="hs-identifier">GHC.Tc.Types.Constraint</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier">Xi</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-33"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html"><span class="hs-identifier">GHC.Core.Coercion.Axiom</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier">CoAxiomRule</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier">BuiltInSynFamily</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#TypeEqn"><span class="hs-identifier">TypeEqn</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-34"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Types.Name.html"><span class="hs-identifier">GHC.Types.Name</span></a></span><span>          </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier">Name</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.Name.html#BuiltInSyntax"><span class="hs-identifier">BuiltInSyntax</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-35"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.html"><span class="hs-identifier">GHC.Builtin.Types</span></a></span><span>
</span><span id="line-36"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Prim.html"><span class="hs-identifier">GHC.Builtin.Types.Prim</span></a></span><span>  </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Prim.html#mkTemplateAnonTyConBinders"><span class="hs-identifier">mkTemplateAnonTyConBinders</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-37"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html"><span class="hs-identifier">GHC.Builtin.Names</span></a></span><span>
</span><span id="line-38"></span><span>                  </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#gHC_TYPELITS"><span class="hs-identifier">gHC_TYPELITS</span></a></span><span>
</span><span id="line-39"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#gHC_TYPENATS"><span class="hs-identifier">gHC_TYPENATS</span></a></span><span>
</span><span id="line-40"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#typeNatAddTyFamNameKey"><span class="hs-identifier">typeNatAddTyFamNameKey</span></a></span><span>
</span><span id="line-41"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#typeNatMulTyFamNameKey"><span class="hs-identifier">typeNatMulTyFamNameKey</span></a></span><span>
</span><span id="line-42"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#typeNatExpTyFamNameKey"><span class="hs-identifier">typeNatExpTyFamNameKey</span></a></span><span>
</span><span id="line-43"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#typeNatLeqTyFamNameKey"><span class="hs-identifier">typeNatLeqTyFamNameKey</span></a></span><span>
</span><span id="line-44"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#typeNatSubTyFamNameKey"><span class="hs-identifier">typeNatSubTyFamNameKey</span></a></span><span>
</span><span id="line-45"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#typeNatDivTyFamNameKey"><span class="hs-identifier">typeNatDivTyFamNameKey</span></a></span><span>
</span><span id="line-46"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#typeNatModTyFamNameKey"><span class="hs-identifier">typeNatModTyFamNameKey</span></a></span><span>
</span><span id="line-47"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#typeNatLogTyFamNameKey"><span class="hs-identifier">typeNatLogTyFamNameKey</span></a></span><span>
</span><span id="line-48"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#typeNatCmpTyFamNameKey"><span class="hs-identifier">typeNatCmpTyFamNameKey</span></a></span><span>
</span><span id="line-49"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#typeSymbolCmpTyFamNameKey"><span class="hs-identifier">typeSymbolCmpTyFamNameKey</span></a></span><span>
</span><span id="line-50"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Names.html#typeSymbolAppendFamNameKey"><span class="hs-identifier">typeSymbolAppendFamNameKey</span></a></span><span>
</span><span id="line-51"></span><span>                  </span><span class="hs-special">)</span><span>
</span><span id="line-52"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Data.FastString.html"><span class="hs-identifier">GHC.Data.FastString</span></a></span><span>
</span><span id="line-53"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../containers/src/Data.Map.html#"><span class="hs-identifier">Data.Map</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Map</span></span><span>
</span><span id="line-54"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Maybe.html#"><span class="hs-identifier">Data.Maybe</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/Data.Maybe.html#isJust"><span class="hs-identifier">isJust</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-55"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.html#"><span class="hs-identifier">Control.Monad</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.html#guard"><span class="hs-identifier">guard</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-56"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.List.html#"><span class="hs-identifier">Data.List</span></a></span><span>  </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/Data.OldList.html#isPrefixOf"><span class="hs-identifier">isPrefixOf</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Data.OldList.html#isSuffixOf"><span class="hs-identifier">isSuffixOf</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-57"></span><span>
</span><span id="line-58"></span><span class="hs-comment">{-
Note [Type-level literals]
~~~~~~~~~~~~~~~~~~~~~~~~~~
There are currently two forms of type-level literals: natural numbers, and
symbols (even though this module is named GHC.Builtin.Types.Literals, it covers both).

Type-level literals are supported by CoAxiomRules (conditional axioms), which
power the built-in type families (see Note [Adding built-in type families]).
Currently, all built-in type families are for the express purpose of supporting
type-level literals.

See also the Wiki page:

    https://gitlab.haskell.org/ghc/ghc/wikis/type-nats

Note [Adding built-in type families]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
There are a few steps to adding a built-in type family:

* Adding a unique for the type family TyCon

  These go in GHC.Builtin.Names. It will likely be of the form
  @myTyFamNameKey = mkPreludeTyConUnique xyz@, where @xyz@ is a number that
  has not been chosen before in GHC.Builtin.Names. There are several examples already
  in GHC.Builtin.Names&#8212;see, for instance, typeNatAddTyFamNameKey.

* Adding the type family TyCon itself

  This goes in GHC.Builtin.Types.Literals. There are plenty of examples of how to define
  these&#8212;see, for instance, typeNatAddTyCon.

  Once your TyCon has been defined, be sure to:

  - Export it from GHC.Builtin.Types.Literals. (Not doing so caused #14632.)
  - Include it in the typeNatTyCons list, defined in GHC.Builtin.Types.Literals.

* Exposing associated type family axioms

  When defining the type family TyCon, you will need to define an axiom for
  the type family in general (see, for instance, axAddDef), and perhaps other
  auxiliary axioms for special cases of the type family (see, for instance,
  axAdd0L and axAdd0R).

  After you have defined all of these axioms, be sure to include them in the
  typeNatCoAxiomRules list, defined in GHC.Builtin.Types.Literals.
  (Not doing so caused #14934.)

* Define the type family somewhere

  Finally, you will need to define the type family somewhere, likely in @base@.
  Currently, all of the built-in type families are defined in GHC.TypeLits or
  GHC.TypeNats, so those are likely candidates.

  Since the behavior of your built-in type family is specified in GHC.Builtin.Types.Literals,
  you should give an open type family definition with no instances, like so:

    type family MyTypeFam (m :: Nat) (n :: Nat) :: Nat

  Changing the argument and result kinds as appropriate.

* Update the relevant test cases

  The GHC test suite will likely need to be updated after you add your built-in
  type family. For instance:

  - The T9181 test prints the :browse contents of GHC.TypeLits, so if you added
    a test there, the expected output of T9181 will need to change.
  - The TcTypeNatSimple and TcTypeSymbolSimple tests have compile-time unit
    tests, as well as TcTypeNatSimpleRun and TcTypeSymbolSimpleRun, which have
    runtime unit tests. Consider adding further unit tests to those if your
    built-in type family deals with Nats or Symbols, respectively.
-}</span><span>
</span><span id="line-130"></span><span>
</span><span id="line-131"></span><span class="hs-comment">{-------------------------------------------------------------------------------
Built-in type constructors for functions on type-level nats
-}</span><span>
</span><span id="line-134"></span><span>
</span><span id="line-135"></span><span class="hs-comment">-- The list of built-in type family TyCons that GHC uses.</span><span>
</span><span id="line-136"></span><span class="hs-comment">-- If you define a built-in type family, make sure to add it to this list.</span><span>
</span><span id="line-137"></span><span class="hs-comment">-- See Note [Adding built-in type families]</span><span>
</span><span id="line-138"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatTyCons"><span class="hs-identifier hs-type">typeNatTyCons</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-139"></span><span id="typeNatTyCons"><span class="annot"><span class="annottext">typeNatTyCons :: [TyCon]
</span><a href="GHC.Builtin.Types.Literals.html#typeNatTyCons"><span class="hs-identifier hs-var hs-var">typeNatTyCons</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-140"></span><span>  </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatAddTyCon"><span class="hs-identifier hs-var">typeNatAddTyCon</span></a></span><span>
</span><span id="line-141"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatMulTyCon"><span class="hs-identifier hs-var">typeNatMulTyCon</span></a></span><span>
</span><span id="line-142"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatExpTyCon"><span class="hs-identifier hs-var">typeNatExpTyCon</span></a></span><span>
</span><span id="line-143"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatLeqTyCon"><span class="hs-identifier hs-var">typeNatLeqTyCon</span></a></span><span>
</span><span id="line-144"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatSubTyCon"><span class="hs-identifier hs-var">typeNatSubTyCon</span></a></span><span>
</span><span id="line-145"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatDivTyCon"><span class="hs-identifier hs-var">typeNatDivTyCon</span></a></span><span>
</span><span id="line-146"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatModTyCon"><span class="hs-identifier hs-var">typeNatModTyCon</span></a></span><span>
</span><span id="line-147"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatLogTyCon"><span class="hs-identifier hs-var">typeNatLogTyCon</span></a></span><span>
</span><span id="line-148"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatCmpTyCon"><span class="hs-identifier hs-var">typeNatCmpTyCon</span></a></span><span>
</span><span id="line-149"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeSymbolCmpTyCon"><span class="hs-identifier hs-var">typeSymbolCmpTyCon</span></a></span><span>
</span><span id="line-150"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeSymbolAppendTyCon"><span class="hs-identifier hs-var">typeSymbolAppendTyCon</span></a></span><span>
</span><span id="line-151"></span><span>  </span><span class="hs-special">]</span><span>
</span><span id="line-152"></span><span>
</span><span id="line-153"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatAddTyCon"><span class="hs-identifier hs-type">typeNatAddTyCon</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-154"></span><span id="typeNatAddTyCon"><span class="annot"><span class="annottext">typeNatAddTyCon :: TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatAddTyCon"><span class="hs-identifier hs-var hs-var">typeNatAddTyCon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; BuiltInSynFamily -&gt; TyCon
</span><a href="GHC.Builtin.Types.Literals.html#mkTypeNatFunTyCon2"><span class="hs-identifier hs-var">mkTypeNatFunTyCon2</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972990"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-155"></span><span>  </span><span class="annot"><span class="annottext">BuiltInSynFamily :: ([Type] -&gt; Maybe (CoAxiomRule, [Type], Type))
-&gt; ([Type] -&gt; Type -&gt; [TypeEqn])
-&gt; ([Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn])
-&gt; BuiltInSynFamily
</span><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span>
</span><span id="line-156"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">sfMatchFam :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Core.Coercion.Axiom.html#sfMatchFam"><span class="hs-identifier hs-var">sfMatchFam</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamAdd"><span class="hs-identifier hs-var">matchFamAdd</span></a></span><span>
</span><span id="line-157"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractTop :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractTop"><span class="hs-identifier hs-var">sfInteractTop</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopAdd"><span class="hs-identifier hs-var">interactTopAdd</span></a></span><span>
</span><span id="line-158"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractInert :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractInert"><span class="hs-identifier hs-var">sfInteractInert</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertAdd"><span class="hs-identifier hs-var">interactInertAdd</span></a></span><span>
</span><span id="line-159"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-160"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-161"></span><span>  </span><span id="local-6989586621680972990"><span class="annot"><span class="annottext">name :: Name
</span><a href="#local-6989586621680972990"><span class="hs-identifier hs-var hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax -&gt; Module -&gt; FastString -&gt; Unique -&gt; TyCon -&gt; Name
</span><a href="GHC.Builtin.Types.html#mkWiredInTyConName"><span class="hs-identifier hs-var">mkWiredInTyConName</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax
</span><a href="GHC.Types.Name.html#UserSyntax"><span class="hs-identifier hs-var">UserSyntax</span></a></span><span> </span><span class="annot"><span class="annottext">Module
</span><a href="GHC.Builtin.Names.html#gHC_TYPENATS"><span class="hs-identifier hs-var">gHC_TYPENATS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;+&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-162"></span><span>            </span><span class="annot"><span class="annottext">Unique
</span><a href="GHC.Builtin.Names.html#typeNatAddTyFamNameKey"><span class="hs-identifier hs-var">typeNatAddTyFamNameKey</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatAddTyCon"><span class="hs-identifier hs-var">typeNatAddTyCon</span></a></span><span>
</span><span id="line-163"></span><span>
</span><span id="line-164"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatSubTyCon"><span class="hs-identifier hs-type">typeNatSubTyCon</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-165"></span><span id="typeNatSubTyCon"><span class="annot"><span class="annottext">typeNatSubTyCon :: TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatSubTyCon"><span class="hs-identifier hs-var hs-var">typeNatSubTyCon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; BuiltInSynFamily -&gt; TyCon
</span><a href="GHC.Builtin.Types.Literals.html#mkTypeNatFunTyCon2"><span class="hs-identifier hs-var">mkTypeNatFunTyCon2</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972979"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-166"></span><span>  </span><span class="annot"><span class="annottext">BuiltInSynFamily :: ([Type] -&gt; Maybe (CoAxiomRule, [Type], Type))
-&gt; ([Type] -&gt; Type -&gt; [TypeEqn])
-&gt; ([Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn])
-&gt; BuiltInSynFamily
</span><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span>
</span><span id="line-167"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">sfMatchFam :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Core.Coercion.Axiom.html#sfMatchFam"><span class="hs-identifier hs-var">sfMatchFam</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamSub"><span class="hs-identifier hs-var">matchFamSub</span></a></span><span>
</span><span id="line-168"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractTop :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractTop"><span class="hs-identifier hs-var">sfInteractTop</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopSub"><span class="hs-identifier hs-var">interactTopSub</span></a></span><span>
</span><span id="line-169"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractInert :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractInert"><span class="hs-identifier hs-var">sfInteractInert</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertSub"><span class="hs-identifier hs-var">interactInertSub</span></a></span><span>
</span><span id="line-170"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-171"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-172"></span><span>  </span><span id="local-6989586621680972979"><span class="annot"><span class="annottext">name :: Name
</span><a href="#local-6989586621680972979"><span class="hs-identifier hs-var hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax -&gt; Module -&gt; FastString -&gt; Unique -&gt; TyCon -&gt; Name
</span><a href="GHC.Builtin.Types.html#mkWiredInTyConName"><span class="hs-identifier hs-var">mkWiredInTyConName</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax
</span><a href="GHC.Types.Name.html#UserSyntax"><span class="hs-identifier hs-var">UserSyntax</span></a></span><span> </span><span class="annot"><span class="annottext">Module
</span><a href="GHC.Builtin.Names.html#gHC_TYPENATS"><span class="hs-identifier hs-var">gHC_TYPENATS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;-&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-173"></span><span>            </span><span class="annot"><span class="annottext">Unique
</span><a href="GHC.Builtin.Names.html#typeNatSubTyFamNameKey"><span class="hs-identifier hs-var">typeNatSubTyFamNameKey</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatSubTyCon"><span class="hs-identifier hs-var">typeNatSubTyCon</span></a></span><span>
</span><span id="line-174"></span><span>
</span><span id="line-175"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatMulTyCon"><span class="hs-identifier hs-type">typeNatMulTyCon</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-176"></span><span id="typeNatMulTyCon"><span class="annot"><span class="annottext">typeNatMulTyCon :: TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatMulTyCon"><span class="hs-identifier hs-var hs-var">typeNatMulTyCon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; BuiltInSynFamily -&gt; TyCon
</span><a href="GHC.Builtin.Types.Literals.html#mkTypeNatFunTyCon2"><span class="hs-identifier hs-var">mkTypeNatFunTyCon2</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972975"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-177"></span><span>  </span><span class="annot"><span class="annottext">BuiltInSynFamily :: ([Type] -&gt; Maybe (CoAxiomRule, [Type], Type))
-&gt; ([Type] -&gt; Type -&gt; [TypeEqn])
-&gt; ([Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn])
-&gt; BuiltInSynFamily
</span><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span>
</span><span id="line-178"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">sfMatchFam :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Core.Coercion.Axiom.html#sfMatchFam"><span class="hs-identifier hs-var">sfMatchFam</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamMul"><span class="hs-identifier hs-var">matchFamMul</span></a></span><span>
</span><span id="line-179"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractTop :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractTop"><span class="hs-identifier hs-var">sfInteractTop</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopMul"><span class="hs-identifier hs-var">interactTopMul</span></a></span><span>
</span><span id="line-180"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractInert :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractInert"><span class="hs-identifier hs-var">sfInteractInert</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertMul"><span class="hs-identifier hs-var">interactInertMul</span></a></span><span>
</span><span id="line-181"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-182"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-183"></span><span>  </span><span id="local-6989586621680972975"><span class="annot"><span class="annottext">name :: Name
</span><a href="#local-6989586621680972975"><span class="hs-identifier hs-var hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax -&gt; Module -&gt; FastString -&gt; Unique -&gt; TyCon -&gt; Name
</span><a href="GHC.Builtin.Types.html#mkWiredInTyConName"><span class="hs-identifier hs-var">mkWiredInTyConName</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax
</span><a href="GHC.Types.Name.html#UserSyntax"><span class="hs-identifier hs-var">UserSyntax</span></a></span><span> </span><span class="annot"><span class="annottext">Module
</span><a href="GHC.Builtin.Names.html#gHC_TYPENATS"><span class="hs-identifier hs-var">gHC_TYPENATS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;*&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-184"></span><span>            </span><span class="annot"><span class="annottext">Unique
</span><a href="GHC.Builtin.Names.html#typeNatMulTyFamNameKey"><span class="hs-identifier hs-var">typeNatMulTyFamNameKey</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatMulTyCon"><span class="hs-identifier hs-var">typeNatMulTyCon</span></a></span><span>
</span><span id="line-185"></span><span>
</span><span id="line-186"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatDivTyCon"><span class="hs-identifier hs-type">typeNatDivTyCon</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-187"></span><span id="typeNatDivTyCon"><span class="annot"><span class="annottext">typeNatDivTyCon :: TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatDivTyCon"><span class="hs-identifier hs-var hs-var">typeNatDivTyCon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; BuiltInSynFamily -&gt; TyCon
</span><a href="GHC.Builtin.Types.Literals.html#mkTypeNatFunTyCon2"><span class="hs-identifier hs-var">mkTypeNatFunTyCon2</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972971"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-188"></span><span>  </span><span class="annot"><span class="annottext">BuiltInSynFamily :: ([Type] -&gt; Maybe (CoAxiomRule, [Type], Type))
-&gt; ([Type] -&gt; Type -&gt; [TypeEqn])
-&gt; ([Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn])
-&gt; BuiltInSynFamily
</span><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span>
</span><span id="line-189"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">sfMatchFam :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Core.Coercion.Axiom.html#sfMatchFam"><span class="hs-identifier hs-var">sfMatchFam</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamDiv"><span class="hs-identifier hs-var">matchFamDiv</span></a></span><span>
</span><span id="line-190"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractTop :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractTop"><span class="hs-identifier hs-var">sfInteractTop</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopDiv"><span class="hs-identifier hs-var">interactTopDiv</span></a></span><span>
</span><span id="line-191"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractInert :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractInert"><span class="hs-identifier hs-var">sfInteractInert</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertDiv"><span class="hs-identifier hs-var">interactInertDiv</span></a></span><span>
</span><span id="line-192"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-193"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-194"></span><span>  </span><span id="local-6989586621680972971"><span class="annot"><span class="annottext">name :: Name
</span><a href="#local-6989586621680972971"><span class="hs-identifier hs-var hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax -&gt; Module -&gt; FastString -&gt; Unique -&gt; TyCon -&gt; Name
</span><a href="GHC.Builtin.Types.html#mkWiredInTyConName"><span class="hs-identifier hs-var">mkWiredInTyConName</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax
</span><a href="GHC.Types.Name.html#UserSyntax"><span class="hs-identifier hs-var">UserSyntax</span></a></span><span> </span><span class="annot"><span class="annottext">Module
</span><a href="GHC.Builtin.Names.html#gHC_TYPENATS"><span class="hs-identifier hs-var">gHC_TYPENATS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Div&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-195"></span><span>            </span><span class="annot"><span class="annottext">Unique
</span><a href="GHC.Builtin.Names.html#typeNatDivTyFamNameKey"><span class="hs-identifier hs-var">typeNatDivTyFamNameKey</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatDivTyCon"><span class="hs-identifier hs-var">typeNatDivTyCon</span></a></span><span>
</span><span id="line-196"></span><span>
</span><span id="line-197"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatModTyCon"><span class="hs-identifier hs-type">typeNatModTyCon</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-198"></span><span id="typeNatModTyCon"><span class="annot"><span class="annottext">typeNatModTyCon :: TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatModTyCon"><span class="hs-identifier hs-var hs-var">typeNatModTyCon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; BuiltInSynFamily -&gt; TyCon
</span><a href="GHC.Builtin.Types.Literals.html#mkTypeNatFunTyCon2"><span class="hs-identifier hs-var">mkTypeNatFunTyCon2</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972967"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-199"></span><span>  </span><span class="annot"><span class="annottext">BuiltInSynFamily :: ([Type] -&gt; Maybe (CoAxiomRule, [Type], Type))
-&gt; ([Type] -&gt; Type -&gt; [TypeEqn])
-&gt; ([Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn])
-&gt; BuiltInSynFamily
</span><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span>
</span><span id="line-200"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">sfMatchFam :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Core.Coercion.Axiom.html#sfMatchFam"><span class="hs-identifier hs-var">sfMatchFam</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamMod"><span class="hs-identifier hs-var">matchFamMod</span></a></span><span>
</span><span id="line-201"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractTop :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractTop"><span class="hs-identifier hs-var">sfInteractTop</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopMod"><span class="hs-identifier hs-var">interactTopMod</span></a></span><span>
</span><span id="line-202"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractInert :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractInert"><span class="hs-identifier hs-var">sfInteractInert</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertMod"><span class="hs-identifier hs-var">interactInertMod</span></a></span><span>
</span><span id="line-203"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-204"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-205"></span><span>  </span><span id="local-6989586621680972967"><span class="annot"><span class="annottext">name :: Name
</span><a href="#local-6989586621680972967"><span class="hs-identifier hs-var hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax -&gt; Module -&gt; FastString -&gt; Unique -&gt; TyCon -&gt; Name
</span><a href="GHC.Builtin.Types.html#mkWiredInTyConName"><span class="hs-identifier hs-var">mkWiredInTyConName</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax
</span><a href="GHC.Types.Name.html#UserSyntax"><span class="hs-identifier hs-var">UserSyntax</span></a></span><span> </span><span class="annot"><span class="annottext">Module
</span><a href="GHC.Builtin.Names.html#gHC_TYPENATS"><span class="hs-identifier hs-var">gHC_TYPENATS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Mod&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-206"></span><span>            </span><span class="annot"><span class="annottext">Unique
</span><a href="GHC.Builtin.Names.html#typeNatModTyFamNameKey"><span class="hs-identifier hs-var">typeNatModTyFamNameKey</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatModTyCon"><span class="hs-identifier hs-var">typeNatModTyCon</span></a></span><span>
</span><span id="line-207"></span><span>
</span><span id="line-208"></span><span>
</span><span id="line-209"></span><span>
</span><span id="line-210"></span><span>
</span><span id="line-211"></span><span>
</span><span id="line-212"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatExpTyCon"><span class="hs-identifier hs-type">typeNatExpTyCon</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-213"></span><span id="typeNatExpTyCon"><span class="annot"><span class="annottext">typeNatExpTyCon :: TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatExpTyCon"><span class="hs-identifier hs-var hs-var">typeNatExpTyCon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; BuiltInSynFamily -&gt; TyCon
</span><a href="GHC.Builtin.Types.Literals.html#mkTypeNatFunTyCon2"><span class="hs-identifier hs-var">mkTypeNatFunTyCon2</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972963"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-214"></span><span>  </span><span class="annot"><span class="annottext">BuiltInSynFamily :: ([Type] -&gt; Maybe (CoAxiomRule, [Type], Type))
-&gt; ([Type] -&gt; Type -&gt; [TypeEqn])
-&gt; ([Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn])
-&gt; BuiltInSynFamily
</span><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span>
</span><span id="line-215"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">sfMatchFam :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Core.Coercion.Axiom.html#sfMatchFam"><span class="hs-identifier hs-var">sfMatchFam</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamExp"><span class="hs-identifier hs-var">matchFamExp</span></a></span><span>
</span><span id="line-216"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractTop :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractTop"><span class="hs-identifier hs-var">sfInteractTop</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopExp"><span class="hs-identifier hs-var">interactTopExp</span></a></span><span>
</span><span id="line-217"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractInert :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractInert"><span class="hs-identifier hs-var">sfInteractInert</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertExp"><span class="hs-identifier hs-var">interactInertExp</span></a></span><span>
</span><span id="line-218"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-219"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-220"></span><span>  </span><span id="local-6989586621680972963"><span class="annot"><span class="annottext">name :: Name
</span><a href="#local-6989586621680972963"><span class="hs-identifier hs-var hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax -&gt; Module -&gt; FastString -&gt; Unique -&gt; TyCon -&gt; Name
</span><a href="GHC.Builtin.Types.html#mkWiredInTyConName"><span class="hs-identifier hs-var">mkWiredInTyConName</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax
</span><a href="GHC.Types.Name.html#UserSyntax"><span class="hs-identifier hs-var">UserSyntax</span></a></span><span> </span><span class="annot"><span class="annottext">Module
</span><a href="GHC.Builtin.Names.html#gHC_TYPENATS"><span class="hs-identifier hs-var">gHC_TYPENATS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;^&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-221"></span><span>                </span><span class="annot"><span class="annottext">Unique
</span><a href="GHC.Builtin.Names.html#typeNatExpTyFamNameKey"><span class="hs-identifier hs-var">typeNatExpTyFamNameKey</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatExpTyCon"><span class="hs-identifier hs-var">typeNatExpTyCon</span></a></span><span>
</span><span id="line-222"></span><span>
</span><span id="line-223"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatLogTyCon"><span class="hs-identifier hs-type">typeNatLogTyCon</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-224"></span><span id="typeNatLogTyCon"><span class="annot"><span class="annottext">typeNatLogTyCon :: TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatLogTyCon"><span class="hs-identifier hs-var hs-var">typeNatLogTyCon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; BuiltInSynFamily -&gt; TyCon
</span><a href="GHC.Builtin.Types.Literals.html#mkTypeNatFunTyCon1"><span class="hs-identifier hs-var">mkTypeNatFunTyCon1</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972958"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-225"></span><span>  </span><span class="annot"><span class="annottext">BuiltInSynFamily :: ([Type] -&gt; Maybe (CoAxiomRule, [Type], Type))
-&gt; ([Type] -&gt; Type -&gt; [TypeEqn])
-&gt; ([Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn])
-&gt; BuiltInSynFamily
</span><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span>
</span><span id="line-226"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">sfMatchFam :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Core.Coercion.Axiom.html#sfMatchFam"><span class="hs-identifier hs-var">sfMatchFam</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamLog"><span class="hs-identifier hs-var">matchFamLog</span></a></span><span>
</span><span id="line-227"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractTop :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractTop"><span class="hs-identifier hs-var">sfInteractTop</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopLog"><span class="hs-identifier hs-var">interactTopLog</span></a></span><span>
</span><span id="line-228"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractInert :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractInert"><span class="hs-identifier hs-var">sfInteractInert</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertLog"><span class="hs-identifier hs-var">interactInertLog</span></a></span><span>
</span><span id="line-229"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-230"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-231"></span><span>  </span><span id="local-6989586621680972958"><span class="annot"><span class="annottext">name :: Name
</span><a href="#local-6989586621680972958"><span class="hs-identifier hs-var hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax -&gt; Module -&gt; FastString -&gt; Unique -&gt; TyCon -&gt; Name
</span><a href="GHC.Builtin.Types.html#mkWiredInTyConName"><span class="hs-identifier hs-var">mkWiredInTyConName</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax
</span><a href="GHC.Types.Name.html#UserSyntax"><span class="hs-identifier hs-var">UserSyntax</span></a></span><span> </span><span class="annot"><span class="annottext">Module
</span><a href="GHC.Builtin.Names.html#gHC_TYPENATS"><span class="hs-identifier hs-var">gHC_TYPENATS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Log2&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-232"></span><span>            </span><span class="annot"><span class="annottext">Unique
</span><a href="GHC.Builtin.Names.html#typeNatLogTyFamNameKey"><span class="hs-identifier hs-var">typeNatLogTyFamNameKey</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatLogTyCon"><span class="hs-identifier hs-var">typeNatLogTyCon</span></a></span><span>
</span><span id="line-233"></span><span>
</span><span id="line-234"></span><span>
</span><span id="line-235"></span><span>
</span><span id="line-236"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatLeqTyCon"><span class="hs-identifier hs-type">typeNatLeqTyCon</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-237"></span><span id="typeNatLeqTyCon"><span class="annot"><span class="annottext">typeNatLeqTyCon :: TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatLeqTyCon"><span class="hs-identifier hs-var hs-var">typeNatLeqTyCon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-238"></span><span>  </span><span class="annot"><span class="annottext">Name
-&gt; [TyConBinder]
-&gt; Type
-&gt; Maybe Name
-&gt; FamTyConFlav
-&gt; Maybe Class
-&gt; Injectivity
-&gt; TyCon
</span><a href="GHC.Core.TyCon.html#mkFamilyTyCon"><span class="hs-identifier hs-var">mkFamilyTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972954"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-239"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Type] -&gt; [TyConBinder]
</span><a href="GHC.Builtin.Types.Prim.html#mkTemplateAnonTyConBinders"><span class="hs-identifier hs-var">mkTemplateAnonTyConBinders</span></a></span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeNatKind"><span class="hs-identifier hs-var">typeNatKind</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeNatKind"><span class="hs-identifier hs-var">typeNatKind</span></a></span><span> </span><span class="hs-special">]</span><span class="hs-special">)</span><span>
</span><span id="line-240"></span><span>    </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#boolTy"><span class="hs-identifier hs-var">boolTy</span></a></span><span>
</span><span id="line-241"></span><span>    </span><span class="annot"><span class="annottext">Maybe Name
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-242"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BuiltInSynFamily -&gt; FamTyConFlav
</span><a href="GHC.Core.TyCon.html#BuiltInSynFamTyCon"><span class="hs-identifier hs-var">BuiltInSynFamTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSynFamily
</span><a href="#local-6989586621680972950"><span class="hs-identifier hs-var">ops</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-243"></span><span>    </span><span class="annot"><span class="annottext">Maybe Class
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-244"></span><span>    </span><span class="annot"><span class="annottext">Injectivity
</span><a href="GHC.Core.TyCon.html#NotInjective"><span class="hs-identifier hs-var">NotInjective</span></a></span><span>
</span><span id="line-245"></span><span>
</span><span id="line-246"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-247"></span><span>  </span><span id="local-6989586621680972954"><span class="annot"><span class="annottext">name :: Name
</span><a href="#local-6989586621680972954"><span class="hs-identifier hs-var hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax -&gt; Module -&gt; FastString -&gt; Unique -&gt; TyCon -&gt; Name
</span><a href="GHC.Builtin.Types.html#mkWiredInTyConName"><span class="hs-identifier hs-var">mkWiredInTyConName</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax
</span><a href="GHC.Types.Name.html#UserSyntax"><span class="hs-identifier hs-var">UserSyntax</span></a></span><span> </span><span class="annot"><span class="annottext">Module
</span><a href="GHC.Builtin.Names.html#gHC_TYPENATS"><span class="hs-identifier hs-var">gHC_TYPENATS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&lt;=?&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-248"></span><span>                </span><span class="annot"><span class="annottext">Unique
</span><a href="GHC.Builtin.Names.html#typeNatLeqTyFamNameKey"><span class="hs-identifier hs-var">typeNatLeqTyFamNameKey</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatLeqTyCon"><span class="hs-identifier hs-var">typeNatLeqTyCon</span></a></span><span>
</span><span id="line-249"></span><span>  </span><span id="local-6989586621680972950"><span class="annot"><span class="annottext">ops :: BuiltInSynFamily
</span><a href="#local-6989586621680972950"><span class="hs-identifier hs-var hs-var">ops</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSynFamily :: ([Type] -&gt; Maybe (CoAxiomRule, [Type], Type))
-&gt; ([Type] -&gt; Type -&gt; [TypeEqn])
-&gt; ([Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn])
-&gt; BuiltInSynFamily
</span><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span>
</span><span id="line-250"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">sfMatchFam :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Core.Coercion.Axiom.html#sfMatchFam"><span class="hs-identifier hs-var">sfMatchFam</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamLeq"><span class="hs-identifier hs-var">matchFamLeq</span></a></span><span>
</span><span id="line-251"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractTop :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractTop"><span class="hs-identifier hs-var">sfInteractTop</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopLeq"><span class="hs-identifier hs-var">interactTopLeq</span></a></span><span>
</span><span id="line-252"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractInert :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractInert"><span class="hs-identifier hs-var">sfInteractInert</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertLeq"><span class="hs-identifier hs-var">interactInertLeq</span></a></span><span>
</span><span id="line-253"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-254"></span><span>
</span><span id="line-255"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatCmpTyCon"><span class="hs-identifier hs-type">typeNatCmpTyCon</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-256"></span><span id="typeNatCmpTyCon"><span class="annot"><span class="annottext">typeNatCmpTyCon :: TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatCmpTyCon"><span class="hs-identifier hs-var hs-var">typeNatCmpTyCon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-257"></span><span>  </span><span class="annot"><span class="annottext">Name
-&gt; [TyConBinder]
-&gt; Type
-&gt; Maybe Name
-&gt; FamTyConFlav
-&gt; Maybe Class
-&gt; Injectivity
-&gt; TyCon
</span><a href="GHC.Core.TyCon.html#mkFamilyTyCon"><span class="hs-identifier hs-var">mkFamilyTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972945"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-258"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Type] -&gt; [TyConBinder]
</span><a href="GHC.Builtin.Types.Prim.html#mkTemplateAnonTyConBinders"><span class="hs-identifier hs-var">mkTemplateAnonTyConBinders</span></a></span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeNatKind"><span class="hs-identifier hs-var">typeNatKind</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeNatKind"><span class="hs-identifier hs-var">typeNatKind</span></a></span><span> </span><span class="hs-special">]</span><span class="hs-special">)</span><span>
</span><span id="line-259"></span><span>    </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.Literals.html#orderingKind"><span class="hs-identifier hs-var">orderingKind</span></a></span><span>
</span><span id="line-260"></span><span>    </span><span class="annot"><span class="annottext">Maybe Name
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-261"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BuiltInSynFamily -&gt; FamTyConFlav
</span><a href="GHC.Core.TyCon.html#BuiltInSynFamTyCon"><span class="hs-identifier hs-var">BuiltInSynFamTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSynFamily
</span><a href="#local-6989586621680972943"><span class="hs-identifier hs-var">ops</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-262"></span><span>    </span><span class="annot"><span class="annottext">Maybe Class
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-263"></span><span>    </span><span class="annot"><span class="annottext">Injectivity
</span><a href="GHC.Core.TyCon.html#NotInjective"><span class="hs-identifier hs-var">NotInjective</span></a></span><span>
</span><span id="line-264"></span><span>
</span><span id="line-265"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-266"></span><span>  </span><span id="local-6989586621680972945"><span class="annot"><span class="annottext">name :: Name
</span><a href="#local-6989586621680972945"><span class="hs-identifier hs-var hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax -&gt; Module -&gt; FastString -&gt; Unique -&gt; TyCon -&gt; Name
</span><a href="GHC.Builtin.Types.html#mkWiredInTyConName"><span class="hs-identifier hs-var">mkWiredInTyConName</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax
</span><a href="GHC.Types.Name.html#UserSyntax"><span class="hs-identifier hs-var">UserSyntax</span></a></span><span> </span><span class="annot"><span class="annottext">Module
</span><a href="GHC.Builtin.Names.html#gHC_TYPENATS"><span class="hs-identifier hs-var">gHC_TYPENATS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;CmpNat&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-267"></span><span>                </span><span class="annot"><span class="annottext">Unique
</span><a href="GHC.Builtin.Names.html#typeNatCmpTyFamNameKey"><span class="hs-identifier hs-var">typeNatCmpTyFamNameKey</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatCmpTyCon"><span class="hs-identifier hs-var">typeNatCmpTyCon</span></a></span><span>
</span><span id="line-268"></span><span>  </span><span id="local-6989586621680972943"><span class="annot"><span class="annottext">ops :: BuiltInSynFamily
</span><a href="#local-6989586621680972943"><span class="hs-identifier hs-var hs-var">ops</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSynFamily :: ([Type] -&gt; Maybe (CoAxiomRule, [Type], Type))
-&gt; ([Type] -&gt; Type -&gt; [TypeEqn])
-&gt; ([Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn])
-&gt; BuiltInSynFamily
</span><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span>
</span><span id="line-269"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">sfMatchFam :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Core.Coercion.Axiom.html#sfMatchFam"><span class="hs-identifier hs-var">sfMatchFam</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamCmpNat"><span class="hs-identifier hs-var">matchFamCmpNat</span></a></span><span>
</span><span id="line-270"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractTop :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractTop"><span class="hs-identifier hs-var">sfInteractTop</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopCmpNat"><span class="hs-identifier hs-var">interactTopCmpNat</span></a></span><span>
</span><span id="line-271"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractInert :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractInert"><span class="hs-identifier hs-var">sfInteractInert</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-272"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-273"></span><span>
</span><span id="line-274"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeSymbolCmpTyCon"><span class="hs-identifier hs-type">typeSymbolCmpTyCon</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-275"></span><span id="typeSymbolCmpTyCon"><span class="annot"><span class="annottext">typeSymbolCmpTyCon :: TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeSymbolCmpTyCon"><span class="hs-identifier hs-var hs-var">typeSymbolCmpTyCon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-276"></span><span>  </span><span class="annot"><span class="annottext">Name
-&gt; [TyConBinder]
-&gt; Type
-&gt; Maybe Name
-&gt; FamTyConFlav
-&gt; Maybe Class
-&gt; Injectivity
-&gt; TyCon
</span><a href="GHC.Core.TyCon.html#mkFamilyTyCon"><span class="hs-identifier hs-var">mkFamilyTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972940"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-277"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Type] -&gt; [TyConBinder]
</span><a href="GHC.Builtin.Types.Prim.html#mkTemplateAnonTyConBinders"><span class="hs-identifier hs-var">mkTemplateAnonTyConBinders</span></a></span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeSymbolKind"><span class="hs-identifier hs-var">typeSymbolKind</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeSymbolKind"><span class="hs-identifier hs-var">typeSymbolKind</span></a></span><span> </span><span class="hs-special">]</span><span class="hs-special">)</span><span>
</span><span id="line-278"></span><span>    </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.Literals.html#orderingKind"><span class="hs-identifier hs-var">orderingKind</span></a></span><span>
</span><span id="line-279"></span><span>    </span><span class="annot"><span class="annottext">Maybe Name
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-280"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BuiltInSynFamily -&gt; FamTyConFlav
</span><a href="GHC.Core.TyCon.html#BuiltInSynFamTyCon"><span class="hs-identifier hs-var">BuiltInSynFamTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSynFamily
</span><a href="#local-6989586621680972938"><span class="hs-identifier hs-var">ops</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-281"></span><span>    </span><span class="annot"><span class="annottext">Maybe Class
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-282"></span><span>    </span><span class="annot"><span class="annottext">Injectivity
</span><a href="GHC.Core.TyCon.html#NotInjective"><span class="hs-identifier hs-var">NotInjective</span></a></span><span>
</span><span id="line-283"></span><span>
</span><span id="line-284"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-285"></span><span>  </span><span id="local-6989586621680972940"><span class="annot"><span class="annottext">name :: Name
</span><a href="#local-6989586621680972940"><span class="hs-identifier hs-var hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax -&gt; Module -&gt; FastString -&gt; Unique -&gt; TyCon -&gt; Name
</span><a href="GHC.Builtin.Types.html#mkWiredInTyConName"><span class="hs-identifier hs-var">mkWiredInTyConName</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax
</span><a href="GHC.Types.Name.html#UserSyntax"><span class="hs-identifier hs-var">UserSyntax</span></a></span><span> </span><span class="annot"><span class="annottext">Module
</span><a href="GHC.Builtin.Names.html#gHC_TYPELITS"><span class="hs-identifier hs-var">gHC_TYPELITS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;CmpSymbol&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-286"></span><span>                </span><span class="annot"><span class="annottext">Unique
</span><a href="GHC.Builtin.Names.html#typeSymbolCmpTyFamNameKey"><span class="hs-identifier hs-var">typeSymbolCmpTyFamNameKey</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeSymbolCmpTyCon"><span class="hs-identifier hs-var">typeSymbolCmpTyCon</span></a></span><span>
</span><span id="line-287"></span><span>  </span><span id="local-6989586621680972938"><span class="annot"><span class="annottext">ops :: BuiltInSynFamily
</span><a href="#local-6989586621680972938"><span class="hs-identifier hs-var hs-var">ops</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSynFamily :: ([Type] -&gt; Maybe (CoAxiomRule, [Type], Type))
-&gt; ([Type] -&gt; Type -&gt; [TypeEqn])
-&gt; ([Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn])
-&gt; BuiltInSynFamily
</span><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span>
</span><span id="line-288"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">sfMatchFam :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Core.Coercion.Axiom.html#sfMatchFam"><span class="hs-identifier hs-var">sfMatchFam</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamCmpSymbol"><span class="hs-identifier hs-var">matchFamCmpSymbol</span></a></span><span>
</span><span id="line-289"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractTop :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractTop"><span class="hs-identifier hs-var">sfInteractTop</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopCmpSymbol"><span class="hs-identifier hs-var">interactTopCmpSymbol</span></a></span><span>
</span><span id="line-290"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractInert :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractInert"><span class="hs-identifier hs-var">sfInteractInert</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-291"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-292"></span><span>
</span><span id="line-293"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeSymbolAppendTyCon"><span class="hs-identifier hs-type">typeSymbolAppendTyCon</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-294"></span><span id="typeSymbolAppendTyCon"><span class="annot"><span class="annottext">typeSymbolAppendTyCon :: TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeSymbolAppendTyCon"><span class="hs-identifier hs-var hs-var">typeSymbolAppendTyCon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; BuiltInSynFamily -&gt; TyCon
</span><a href="GHC.Builtin.Types.Literals.html#mkTypeSymbolFunTyCon2"><span class="hs-identifier hs-var">mkTypeSymbolFunTyCon2</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972934"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-295"></span><span>  </span><span class="annot"><span class="annottext">BuiltInSynFamily :: ([Type] -&gt; Maybe (CoAxiomRule, [Type], Type))
-&gt; ([Type] -&gt; Type -&gt; [TypeEqn])
-&gt; ([Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn])
-&gt; BuiltInSynFamily
</span><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span>
</span><span id="line-296"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">sfMatchFam :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Core.Coercion.Axiom.html#sfMatchFam"><span class="hs-identifier hs-var">sfMatchFam</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamAppendSymbol"><span class="hs-identifier hs-var">matchFamAppendSymbol</span></a></span><span>
</span><span id="line-297"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractTop :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractTop"><span class="hs-identifier hs-var">sfInteractTop</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopAppendSymbol"><span class="hs-identifier hs-var">interactTopAppendSymbol</span></a></span><span>
</span><span id="line-298"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">sfInteractInert :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Core.Coercion.Axiom.html#sfInteractInert"><span class="hs-identifier hs-var">sfInteractInert</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertAppendSymbol"><span class="hs-identifier hs-var">interactInertAppendSymbol</span></a></span><span>
</span><span id="line-299"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-300"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-301"></span><span>  </span><span id="local-6989586621680972934"><span class="annot"><span class="annottext">name :: Name
</span><a href="#local-6989586621680972934"><span class="hs-identifier hs-var hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax -&gt; Module -&gt; FastString -&gt; Unique -&gt; TyCon -&gt; Name
</span><a href="GHC.Builtin.Types.html#mkWiredInTyConName"><span class="hs-identifier hs-var">mkWiredInTyConName</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSyntax
</span><a href="GHC.Types.Name.html#UserSyntax"><span class="hs-identifier hs-var">UserSyntax</span></a></span><span> </span><span class="annot"><span class="annottext">Module
</span><a href="GHC.Builtin.Names.html#gHC_TYPELITS"><span class="hs-identifier hs-var">gHC_TYPELITS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;AppendSymbol&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-302"></span><span>                </span><span class="annot"><span class="annottext">Unique
</span><a href="GHC.Builtin.Names.html#typeSymbolAppendFamNameKey"><span class="hs-identifier hs-var">typeSymbolAppendFamNameKey</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeSymbolAppendTyCon"><span class="hs-identifier hs-var">typeSymbolAppendTyCon</span></a></span><span>
</span><span id="line-303"></span><span>
</span><span id="line-304"></span><span>
</span><span id="line-305"></span><span>
</span><span id="line-306"></span><span class="hs-comment">-- Make a unary built-in constructor of kind: Nat -&gt; Nat</span><span>
</span><span id="line-307"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#mkTypeNatFunTyCon1"><span class="hs-identifier hs-type">mkTypeNatFunTyCon1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-308"></span><span id="mkTypeNatFunTyCon1"><span class="annot"><span class="annottext">mkTypeNatFunTyCon1 :: Name -&gt; BuiltInSynFamily -&gt; TyCon
</span><a href="GHC.Builtin.Types.Literals.html#mkTypeNatFunTyCon1"><span class="hs-identifier hs-var hs-var">mkTypeNatFunTyCon1</span></a></span></span><span> </span><span id="local-6989586621680972930"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972930"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span id="local-6989586621680972929"><span class="annot"><span class="annottext">BuiltInSynFamily
</span><a href="#local-6989586621680972929"><span class="hs-identifier hs-var">tcb</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-309"></span><span>  </span><span class="annot"><span class="annottext">Name
-&gt; [TyConBinder]
-&gt; Type
-&gt; Maybe Name
-&gt; FamTyConFlav
-&gt; Maybe Class
-&gt; Injectivity
-&gt; TyCon
</span><a href="GHC.Core.TyCon.html#mkFamilyTyCon"><span class="hs-identifier hs-var">mkFamilyTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972930"><span class="hs-identifier hs-var">op</span></a></span><span>
</span><span id="line-310"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Type] -&gt; [TyConBinder]
</span><a href="GHC.Builtin.Types.Prim.html#mkTemplateAnonTyConBinders"><span class="hs-identifier hs-var">mkTemplateAnonTyConBinders</span></a></span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeNatKind"><span class="hs-identifier hs-var">typeNatKind</span></a></span><span> </span><span class="hs-special">]</span><span class="hs-special">)</span><span>
</span><span id="line-311"></span><span>    </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeNatKind"><span class="hs-identifier hs-var">typeNatKind</span></a></span><span>
</span><span id="line-312"></span><span>    </span><span class="annot"><span class="annottext">Maybe Name
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-313"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BuiltInSynFamily -&gt; FamTyConFlav
</span><a href="GHC.Core.TyCon.html#BuiltInSynFamTyCon"><span class="hs-identifier hs-var">BuiltInSynFamTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSynFamily
</span><a href="#local-6989586621680972929"><span class="hs-identifier hs-var">tcb</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-314"></span><span>    </span><span class="annot"><span class="annottext">Maybe Class
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-315"></span><span>    </span><span class="annot"><span class="annottext">Injectivity
</span><a href="GHC.Core.TyCon.html#NotInjective"><span class="hs-identifier hs-var">NotInjective</span></a></span><span>
</span><span id="line-316"></span><span>
</span><span id="line-317"></span><span>
</span><span id="line-318"></span><span class="hs-comment">-- Make a binary built-in constructor of kind: Nat -&gt; Nat -&gt; Nat</span><span>
</span><span id="line-319"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#mkTypeNatFunTyCon2"><span class="hs-identifier hs-type">mkTypeNatFunTyCon2</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-320"></span><span id="mkTypeNatFunTyCon2"><span class="annot"><span class="annottext">mkTypeNatFunTyCon2 :: Name -&gt; BuiltInSynFamily -&gt; TyCon
</span><a href="GHC.Builtin.Types.Literals.html#mkTypeNatFunTyCon2"><span class="hs-identifier hs-var hs-var">mkTypeNatFunTyCon2</span></a></span></span><span> </span><span id="local-6989586621680972928"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972928"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span id="local-6989586621680972927"><span class="annot"><span class="annottext">BuiltInSynFamily
</span><a href="#local-6989586621680972927"><span class="hs-identifier hs-var">tcb</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-321"></span><span>  </span><span class="annot"><span class="annottext">Name
-&gt; [TyConBinder]
-&gt; Type
-&gt; Maybe Name
-&gt; FamTyConFlav
-&gt; Maybe Class
-&gt; Injectivity
-&gt; TyCon
</span><a href="GHC.Core.TyCon.html#mkFamilyTyCon"><span class="hs-identifier hs-var">mkFamilyTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972928"><span class="hs-identifier hs-var">op</span></a></span><span>
</span><span id="line-322"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Type] -&gt; [TyConBinder]
</span><a href="GHC.Builtin.Types.Prim.html#mkTemplateAnonTyConBinders"><span class="hs-identifier hs-var">mkTemplateAnonTyConBinders</span></a></span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeNatKind"><span class="hs-identifier hs-var">typeNatKind</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeNatKind"><span class="hs-identifier hs-var">typeNatKind</span></a></span><span> </span><span class="hs-special">]</span><span class="hs-special">)</span><span>
</span><span id="line-323"></span><span>    </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeNatKind"><span class="hs-identifier hs-var">typeNatKind</span></a></span><span>
</span><span id="line-324"></span><span>    </span><span class="annot"><span class="annottext">Maybe Name
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-325"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BuiltInSynFamily -&gt; FamTyConFlav
</span><a href="GHC.Core.TyCon.html#BuiltInSynFamTyCon"><span class="hs-identifier hs-var">BuiltInSynFamTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSynFamily
</span><a href="#local-6989586621680972927"><span class="hs-identifier hs-var">tcb</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-326"></span><span>    </span><span class="annot"><span class="annottext">Maybe Class
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-327"></span><span>    </span><span class="annot"><span class="annottext">Injectivity
</span><a href="GHC.Core.TyCon.html#NotInjective"><span class="hs-identifier hs-var">NotInjective</span></a></span><span>
</span><span id="line-328"></span><span>
</span><span id="line-329"></span><span class="hs-comment">-- Make a binary built-in constructor of kind: Symbol -&gt; Symbol -&gt; Symbol</span><span>
</span><span id="line-330"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#mkTypeSymbolFunTyCon2"><span class="hs-identifier hs-type">mkTypeSymbolFunTyCon2</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#BuiltInSynFamily"><span class="hs-identifier hs-type">BuiltInSynFamily</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span>
</span><span id="line-331"></span><span id="mkTypeSymbolFunTyCon2"><span class="annot"><span class="annottext">mkTypeSymbolFunTyCon2 :: Name -&gt; BuiltInSynFamily -&gt; TyCon
</span><a href="GHC.Builtin.Types.Literals.html#mkTypeSymbolFunTyCon2"><span class="hs-identifier hs-var hs-var">mkTypeSymbolFunTyCon2</span></a></span></span><span> </span><span id="local-6989586621680972926"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972926"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span id="local-6989586621680972925"><span class="annot"><span class="annottext">BuiltInSynFamily
</span><a href="#local-6989586621680972925"><span class="hs-identifier hs-var">tcb</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-332"></span><span>  </span><span class="annot"><span class="annottext">Name
-&gt; [TyConBinder]
-&gt; Type
-&gt; Maybe Name
-&gt; FamTyConFlav
-&gt; Maybe Class
-&gt; Injectivity
-&gt; TyCon
</span><a href="GHC.Core.TyCon.html#mkFamilyTyCon"><span class="hs-identifier hs-var">mkFamilyTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621680972926"><span class="hs-identifier hs-var">op</span></a></span><span>
</span><span id="line-333"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Type] -&gt; [TyConBinder]
</span><a href="GHC.Builtin.Types.Prim.html#mkTemplateAnonTyConBinders"><span class="hs-identifier hs-var">mkTemplateAnonTyConBinders</span></a></span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeSymbolKind"><span class="hs-identifier hs-var">typeSymbolKind</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeSymbolKind"><span class="hs-identifier hs-var">typeSymbolKind</span></a></span><span> </span><span class="hs-special">]</span><span class="hs-special">)</span><span>
</span><span id="line-334"></span><span>    </span><span class="annot"><span class="annottext">Type
</span><a href="GHC.Builtin.Types.html#typeSymbolKind"><span class="hs-identifier hs-var">typeSymbolKind</span></a></span><span>
</span><span id="line-335"></span><span>    </span><span class="annot"><span class="annottext">Maybe Name
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-336"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BuiltInSynFamily -&gt; FamTyConFlav
</span><a href="GHC.Core.TyCon.html#BuiltInSynFamTyCon"><span class="hs-identifier hs-var">BuiltInSynFamTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">BuiltInSynFamily
</span><a href="#local-6989586621680972925"><span class="hs-identifier hs-var">tcb</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-337"></span><span>    </span><span class="annot"><span class="annottext">Maybe Class
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-338"></span><span>    </span><span class="annot"><span class="annottext">Injectivity
</span><a href="GHC.Core.TyCon.html#NotInjective"><span class="hs-identifier hs-var">NotInjective</span></a></span><span>
</span><span id="line-339"></span><span>
</span><span id="line-340"></span><span>
</span><span id="line-341"></span><span class="hs-comment">{-------------------------------------------------------------------------------
Built-in rules axioms
-------------------------------------------------------------------------------}</span><span>
</span><span id="line-344"></span><span>
</span><span id="line-345"></span><span class="hs-comment">-- If you add additional rules, please remember to add them to</span><span>
</span><span id="line-346"></span><span class="hs-comment">-- `typeNatCoAxiomRules` also.</span><span>
</span><span id="line-347"></span><span class="hs-comment">-- See Note [Adding built-in type families]</span><span>
</span><span id="line-348"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axAddDef"><span class="hs-identifier hs-type">axAddDef</span></a></span><span>
</span><span id="line-349"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axMulDef"><span class="hs-identifier hs-type">axMulDef</span></a></span><span>
</span><span id="line-350"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axExpDef"><span class="hs-identifier hs-type">axExpDef</span></a></span><span>
</span><span id="line-351"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axLeqDef"><span class="hs-identifier hs-type">axLeqDef</span></a></span><span>
</span><span id="line-352"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axCmpNatDef"><span class="hs-identifier hs-type">axCmpNatDef</span></a></span><span>
</span><span id="line-353"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axCmpSymbolDef"><span class="hs-identifier hs-type">axCmpSymbolDef</span></a></span><span>
</span><span id="line-354"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axAppendSymbolDef"><span class="hs-identifier hs-type">axAppendSymbolDef</span></a></span><span>
</span><span id="line-355"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axAdd0L"><span class="hs-identifier hs-type">axAdd0L</span></a></span><span>
</span><span id="line-356"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axAdd0R"><span class="hs-identifier hs-type">axAdd0R</span></a></span><span>
</span><span id="line-357"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axMul0L"><span class="hs-identifier hs-type">axMul0L</span></a></span><span>
</span><span id="line-358"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axMul0R"><span class="hs-identifier hs-type">axMul0R</span></a></span><span>
</span><span id="line-359"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axMul1L"><span class="hs-identifier hs-type">axMul1L</span></a></span><span>
</span><span id="line-360"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axMul1R"><span class="hs-identifier hs-type">axMul1R</span></a></span><span>
</span><span id="line-361"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axExp1L"><span class="hs-identifier hs-type">axExp1L</span></a></span><span>
</span><span id="line-362"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axExp0R"><span class="hs-identifier hs-type">axExp0R</span></a></span><span>
</span><span id="line-363"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axExp1R"><span class="hs-identifier hs-type">axExp1R</span></a></span><span>
</span><span id="line-364"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axLeqRefl"><span class="hs-identifier hs-type">axLeqRefl</span></a></span><span>
</span><span id="line-365"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axCmpNatRefl"><span class="hs-identifier hs-type">axCmpNatRefl</span></a></span><span>
</span><span id="line-366"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axCmpSymbolRefl"><span class="hs-identifier hs-type">axCmpSymbolRefl</span></a></span><span>
</span><span id="line-367"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axLeq0L"><span class="hs-identifier hs-type">axLeq0L</span></a></span><span>
</span><span id="line-368"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axSubDef"><span class="hs-identifier hs-type">axSubDef</span></a></span><span>
</span><span id="line-369"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axSub0R"><span class="hs-identifier hs-type">axSub0R</span></a></span><span>
</span><span id="line-370"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axAppendSymbol0R"><span class="hs-identifier hs-type">axAppendSymbol0R</span></a></span><span>
</span><span id="line-371"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axAppendSymbol0L"><span class="hs-identifier hs-type">axAppendSymbol0L</span></a></span><span>
</span><span id="line-372"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axDivDef"><span class="hs-identifier hs-type">axDivDef</span></a></span><span>
</span><span id="line-373"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axDiv1"><span class="hs-identifier hs-type">axDiv1</span></a></span><span>
</span><span id="line-374"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axModDef"><span class="hs-identifier hs-type">axModDef</span></a></span><span>
</span><span id="line-375"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axMod1"><span class="hs-identifier hs-type">axMod1</span></a></span><span>
</span><span id="line-376"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#axLogDef"><span class="hs-identifier hs-type">axLogDef</span></a></span><span>
</span><span id="line-377"></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span>
</span><span id="line-378"></span><span>
</span><span id="line-379"></span><span id="axAddDef"><span class="annot"><span class="annottext">axAddDef :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAddDef"><span class="hs-identifier hs-var hs-var">axAddDef</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String
-&gt; TyCon -&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkBinAxiom"><span class="hs-identifier hs-var">mkBinAxiom</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;AddDef&quot;</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatAddTyCon"><span class="hs-identifier hs-var">typeNatAddTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">((Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule)
-&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-380"></span><span>              </span><span class="hs-glyph">\</span><span id="local-6989586621680972894"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972894"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972893"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972893"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Type
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; Maybe Type) -&gt; Type -&gt; Maybe Type
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972894"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972893"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-381"></span><span>
</span><span id="line-382"></span><span id="axMulDef"><span class="annot"><span class="annottext">axMulDef :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMulDef"><span class="hs-identifier hs-var hs-var">axMulDef</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String
-&gt; TyCon -&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkBinAxiom"><span class="hs-identifier hs-var">mkBinAxiom</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;MulDef&quot;</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatMulTyCon"><span class="hs-identifier hs-var">typeNatMulTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">((Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule)
-&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-383"></span><span>              </span><span class="hs-glyph">\</span><span id="local-6989586621680972890"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972890"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972889"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972889"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Type
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; Maybe Type) -&gt; Type -&gt; Maybe Type
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972890"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972889"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-384"></span><span>
</span><span id="line-385"></span><span id="axExpDef"><span class="annot"><span class="annottext">axExpDef :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axExpDef"><span class="hs-identifier hs-var hs-var">axExpDef</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String
-&gt; TyCon -&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkBinAxiom"><span class="hs-identifier hs-var">mkBinAxiom</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;ExpDef&quot;</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatExpTyCon"><span class="hs-identifier hs-var">typeNatExpTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">((Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule)
-&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-386"></span><span>              </span><span class="hs-glyph">\</span><span id="local-6989586621680972887"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972887"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972886"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972886"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Type
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; Maybe Type) -&gt; Type -&gt; Maybe Type
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972887"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a b. (Num a, Integral b) =&gt; a -&gt; b -&gt; a
</span><a href="../../base/src/GHC.Real.html#%5E"><span class="hs-operator hs-var">^</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972886"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-387"></span><span>
</span><span id="line-388"></span><span id="axLeqDef"><span class="annot"><span class="annottext">axLeqDef :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axLeqDef"><span class="hs-identifier hs-var hs-var">axLeqDef</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String
-&gt; TyCon -&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkBinAxiom"><span class="hs-identifier hs-var">mkBinAxiom</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;LeqDef&quot;</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatLeqTyCon"><span class="hs-identifier hs-var">typeNatLeqTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">((Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule)
-&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-389"></span><span>              </span><span class="hs-glyph">\</span><span id="local-6989586621680972884"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972884"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972883"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972883"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Type
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; Maybe Type) -&gt; Type -&gt; Maybe Type
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#bool"><span class="hs-identifier hs-var">bool</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972884"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972883"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-390"></span><span>
</span><span id="line-391"></span><span id="axCmpNatDef"><span class="annot"><span class="annottext">axCmpNatDef :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axCmpNatDef"><span class="hs-identifier hs-var hs-var">axCmpNatDef</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String
-&gt; TyCon -&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkBinAxiom"><span class="hs-identifier hs-var">mkBinAxiom</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;CmpNatDef&quot;</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatCmpTyCon"><span class="hs-identifier hs-var">typeNatCmpTyCon</span></a></span><span>
</span><span id="line-392"></span><span>              </span><span class="annot"><span class="annottext">((Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule)
-&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680972880"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972880"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972879"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972879"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Type
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; Maybe Type) -&gt; Type -&gt; Maybe Type
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#ordering"><span class="hs-identifier hs-var">ordering</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><span class="hs-identifier hs-var">compare</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972880"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972879"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-393"></span><span>
</span><span id="line-394"></span><span id="axCmpSymbolDef"><span class="annot"><span class="annottext">axCmpSymbolDef :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axCmpSymbolDef"><span class="hs-identifier hs-var hs-var">axCmpSymbolDef</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-395"></span><span>  </span><span class="annot"><span class="annottext">CoAxiomRule :: FastString
-&gt; [Role] -&gt; Role -&gt; ([TypeEqn] -&gt; Maybe TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span>
</span><span id="line-396"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">coaxrName :: FastString
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrName"><span class="hs-identifier hs-var">coaxrName</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;CmpSymbolDef&quot;</span></span><span>
</span><span id="line-397"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrAsmpRoles :: [Role]
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrAsmpRoles"><span class="hs-identifier hs-var">coaxrAsmpRoles</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-398"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrRole :: Role
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrRole"><span class="hs-identifier hs-var">coaxrRole</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span>
</span><span id="line-399"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrProves :: [TypeEqn] -&gt; Maybe TypeEqn
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrProves"><span class="hs-identifier hs-var">coaxrProves</span></a></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680972870"><span class="annot"><span class="annottext">[TypeEqn]
</span><a href="#local-6989586621680972870"><span class="hs-identifier hs-var">cs</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-400"></span><span>        </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972868"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972868"><span class="hs-identifier hs-var">s1</span></a></span></span><span> </span><span id="local-6989586621680972867"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972867"><span class="hs-identifier hs-var">s2</span></a></span></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972866"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972866"><span class="hs-identifier hs-var">t1</span></a></span></span><span> </span><span id="local-6989586621680972865"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972865"><span class="hs-identifier hs-var">t2</span></a></span></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[TypeEqn] -&gt; Maybe [TypeEqn]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">[TypeEqn]
</span><a href="#local-6989586621680972870"><span class="hs-identifier hs-var">cs</span></a></span><span>
</span><span id="line-401"></span><span>           </span><span id="local-6989586621680972864"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972864"><span class="hs-identifier hs-var">s2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe FastString
</span><a href="GHC.Core.Type.html#isStrLitTy"><span class="hs-identifier hs-var">isStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972867"><span class="hs-identifier hs-var">s2</span></a></span><span>
</span><span id="line-402"></span><span>           </span><span id="local-6989586621680972862"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972862"><span class="hs-identifier hs-var">t2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe FastString
</span><a href="GHC.Core.Type.html#isStrLitTy"><span class="hs-identifier hs-var">isStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972865"><span class="hs-identifier hs-var">t2</span></a></span><span>
</span><span id="line-403"></span><span>           </span><span class="annot"><span class="annottext">TypeEqn -&gt; Maybe TypeEqn
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeSymbolCmpTyCon"><span class="hs-identifier hs-var">typeSymbolCmpTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972868"><span class="hs-identifier hs-var">s1</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972866"><span class="hs-identifier hs-var">t1</span></a></span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span>
</span><span id="line-404"></span><span>                   </span><span class="annot"><span class="annottext">Ordering -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#ordering"><span class="hs-identifier hs-var">ordering</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FastString -&gt; FastString -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><span class="hs-identifier hs-var">compare</span></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972864"><span class="hs-identifier hs-var">s2'</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972862"><span class="hs-identifier hs-var">t2'</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-405"></span><span>
</span><span id="line-406"></span><span id="axAppendSymbolDef"><span class="annot"><span class="annottext">axAppendSymbolDef :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAppendSymbolDef"><span class="hs-identifier hs-var hs-var">axAppendSymbolDef</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule :: FastString
-&gt; [Role] -&gt; Role -&gt; ([TypeEqn] -&gt; Maybe TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span>
</span><span id="line-407"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">coaxrName :: FastString
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrName"><span class="hs-identifier hs-var">coaxrName</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;AppendSymbolDef&quot;</span></span><span>
</span><span id="line-408"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrAsmpRoles :: [Role]
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrAsmpRoles"><span class="hs-identifier hs-var">coaxrAsmpRoles</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-409"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrRole :: Role
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrRole"><span class="hs-identifier hs-var">coaxrRole</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span>
</span><span id="line-410"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrProves :: [TypeEqn] -&gt; Maybe TypeEqn
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrProves"><span class="hs-identifier hs-var">coaxrProves</span></a></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680972859"><span class="annot"><span class="annottext">[TypeEqn]
</span><a href="#local-6989586621680972859"><span class="hs-identifier hs-var">cs</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-411"></span><span>        </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972858"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972858"><span class="hs-identifier hs-var">s1</span></a></span></span><span> </span><span id="local-6989586621680972857"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972857"><span class="hs-identifier hs-var">s2</span></a></span></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972856"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972856"><span class="hs-identifier hs-var">t1</span></a></span></span><span> </span><span id="local-6989586621680972855"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972855"><span class="hs-identifier hs-var">t2</span></a></span></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[TypeEqn] -&gt; Maybe [TypeEqn]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">[TypeEqn]
</span><a href="#local-6989586621680972859"><span class="hs-identifier hs-var">cs</span></a></span><span>
</span><span id="line-412"></span><span>           </span><span id="local-6989586621680972854"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972854"><span class="hs-identifier hs-var">s2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe FastString
</span><a href="GHC.Core.Type.html#isStrLitTy"><span class="hs-identifier hs-var">isStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972857"><span class="hs-identifier hs-var">s2</span></a></span><span>
</span><span id="line-413"></span><span>           </span><span id="local-6989586621680972853"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972853"><span class="hs-identifier hs-var">t2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe FastString
</span><a href="GHC.Core.Type.html#isStrLitTy"><span class="hs-identifier hs-var">isStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972855"><span class="hs-identifier hs-var">t2</span></a></span><span>
</span><span id="line-414"></span><span>           </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680972852"><span class="annot"><span class="annottext">z :: Type
</span><a href="#local-6989586621680972852"><span class="hs-identifier hs-var hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">FastString -&gt; Type
</span><a href="GHC.Core.Type.html#mkStrLitTy"><span class="hs-identifier hs-var">mkStrLitTy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FastString -&gt; FastString -&gt; FastString
</span><a href="GHC.Data.FastString.html#appendFS"><span class="hs-identifier hs-var">appendFS</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972854"><span class="hs-identifier hs-var">s2'</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972853"><span class="hs-identifier hs-var">t2'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-415"></span><span>           </span><span class="annot"><span class="annottext">TypeEqn -&gt; Maybe TypeEqn
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeSymbolAppendTyCon"><span class="hs-identifier hs-var">typeSymbolAppendTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972858"><span class="hs-identifier hs-var">s1</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972856"><span class="hs-identifier hs-var">t1</span></a></span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972852"><span class="hs-identifier hs-var">z</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-416"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-417"></span><span>
</span><span id="line-418"></span><span id="axSubDef"><span class="annot"><span class="annottext">axSubDef :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axSubDef"><span class="hs-identifier hs-var hs-var">axSubDef</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String
-&gt; TyCon -&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkBinAxiom"><span class="hs-identifier hs-var">mkBinAxiom</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SubDef&quot;</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatSubTyCon"><span class="hs-identifier hs-var">typeNatSubTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">((Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule)
-&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-419"></span><span>              </span><span class="hs-glyph">\</span><span id="local-6989586621680972849"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972849"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972848"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972848"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Type) -&gt; Maybe Integer -&gt; Maybe Type
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe Integer
</span><a href="GHC.Builtin.Types.Literals.html#minus"><span class="hs-identifier hs-var">minus</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972849"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972848"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-420"></span><span>
</span><span id="line-421"></span><span id="axDivDef"><span class="annot"><span class="annottext">axDivDef :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axDivDef"><span class="hs-identifier hs-var hs-var">axDivDef</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String
-&gt; TyCon -&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkBinAxiom"><span class="hs-identifier hs-var">mkBinAxiom</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DivDef&quot;</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatDivTyCon"><span class="hs-identifier hs-var">typeNatDivTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">((Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule)
-&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-422"></span><span>              </span><span class="hs-glyph">\</span><span id="local-6989586621680972846"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972846"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972845"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972845"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Maybe ()
forall (f :: * -&gt; *). Alternative f =&gt; Bool -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#guard"><span class="hs-identifier hs-var">guard</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972845"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-423"></span><span>                         </span><span class="annot"><span class="annottext">Type -&gt; Maybe Type
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#div"><span class="hs-identifier hs-var">div</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972846"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972845"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-424"></span><span>
</span><span id="line-425"></span><span id="axModDef"><span class="annot"><span class="annottext">axModDef :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axModDef"><span class="hs-identifier hs-var hs-var">axModDef</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String
-&gt; TyCon -&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkBinAxiom"><span class="hs-identifier hs-var">mkBinAxiom</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;ModDef&quot;</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatModTyCon"><span class="hs-identifier hs-var">typeNatModTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">((Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule)
-&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-426"></span><span>              </span><span class="hs-glyph">\</span><span id="local-6989586621680972842"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972842"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972841"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972841"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Maybe ()
forall (f :: * -&gt; *). Alternative f =&gt; Bool -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#guard"><span class="hs-identifier hs-var">guard</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972841"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-427"></span><span>                         </span><span class="annot"><span class="annottext">Type -&gt; Maybe Type
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#mod"><span class="hs-identifier hs-var">mod</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972842"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972841"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-428"></span><span>
</span><span id="line-429"></span><span id="axLogDef"><span class="annot"><span class="annottext">axLogDef :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axLogDef"><span class="hs-identifier hs-var hs-var">axLogDef</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; TyCon -&gt; (Integer -&gt; Maybe Type) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkUnAxiom"><span class="hs-identifier hs-var">mkUnAxiom</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;LogDef&quot;</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatLogTyCon"><span class="hs-identifier hs-var">typeNatLogTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">((Integer -&gt; Maybe Type) -&gt; CoAxiomRule)
-&gt; (Integer -&gt; Maybe Type) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-430"></span><span>              </span><span class="hs-glyph">\</span><span id="local-6989586621680972838"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972838"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">(</span><span id="local-6989586621680972837"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972837"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe (Integer, Bool)
</span><a href="GHC.Builtin.Types.Literals.html#genLog"><span class="hs-identifier hs-var">genLog</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972838"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">2</span></span><span>
</span><span id="line-431"></span><span>                       </span><span class="annot"><span class="annottext">Type -&gt; Maybe Type
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972837"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-432"></span><span>
</span><span id="line-433"></span><span id="axAdd0L"><span class="annot"><span class="annottext">axAdd0L :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAdd0L"><span class="hs-identifier hs-var hs-var">axAdd0L</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Add0L&quot;</span></span><span>    </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972834"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972834"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972833"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972833"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%2B."><span class="hs-operator hs-var">.+.</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972834"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972833"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-434"></span><span id="axAdd0R"><span class="annot"><span class="annottext">axAdd0R :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAdd0R"><span class="hs-identifier hs-var hs-var">axAdd0R</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Add0R&quot;</span></span><span>    </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972831"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972831"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972830"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972830"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972831"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%2B."><span class="hs-operator hs-var">.+.</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972830"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-435"></span><span id="axSub0R"><span class="annot"><span class="annottext">axSub0R :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axSub0R"><span class="hs-identifier hs-var hs-var">axSub0R</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Sub0R&quot;</span></span><span>    </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972829"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972829"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972828"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972828"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972829"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.-."><span class="hs-operator hs-var">.-.</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972828"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-436"></span><span id="axMul0L"><span class="annot"><span class="annottext">axMul0L :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMul0L"><span class="hs-identifier hs-var hs-var">axMul0L</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Mul0L&quot;</span></span><span>    </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972826"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972826"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%2A."><span class="hs-operator hs-var">.*.</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972826"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span>
</span><span id="line-437"></span><span id="axMul0R"><span class="annot"><span class="annottext">axMul0R :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMul0R"><span class="hs-identifier hs-var hs-var">axMul0R</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Mul0R&quot;</span></span><span>    </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972824"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972824"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972824"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%2A."><span class="hs-operator hs-var">.*.</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span>
</span><span id="line-438"></span><span id="axMul1L"><span class="annot"><span class="annottext">axMul1L :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMul1L"><span class="hs-identifier hs-var hs-var">axMul1L</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Mul1L&quot;</span></span><span>    </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972823"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972823"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972822"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972822"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%2A."><span class="hs-operator hs-var">.*.</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972823"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972822"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-439"></span><span id="axMul1R"><span class="annot"><span class="annottext">axMul1R :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMul1R"><span class="hs-identifier hs-var hs-var">axMul1R</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Mul1R&quot;</span></span><span>    </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972821"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972821"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972820"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972820"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972821"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%2A."><span class="hs-operator hs-var">.*.</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972820"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-440"></span><span id="axDiv1"><span class="annot"><span class="annottext">axDiv1 :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axDiv1"><span class="hs-identifier hs-var hs-var">axDiv1</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Div1&quot;</span></span><span>     </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972819"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972819"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972818"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972818"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#tDiv"><span class="hs-identifier hs-var">tDiv</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972819"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972818"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-441"></span><span id="axMod1"><span class="annot"><span class="annottext">axMod1 :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMod1"><span class="hs-identifier hs-var hs-var">axMod1</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Mod1&quot;</span></span><span>     </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972816"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972816"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#tMod"><span class="hs-identifier hs-var">tMod</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972816"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-442"></span><span>                                    </span><span class="hs-comment">-- XXX: Shouldn't we check that _ is 0?</span><span>
</span><span id="line-443"></span><span id="axExp1L"><span class="annot"><span class="annottext">axExp1L :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axExp1L"><span class="hs-identifier hs-var hs-var">axExp1L</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Exp1L&quot;</span></span><span>    </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972814"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972814"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%5E."><span class="hs-operator hs-var">.^.</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972814"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span>
</span><span id="line-444"></span><span id="axExp0R"><span class="annot"><span class="annottext">axExp0R :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axExp0R"><span class="hs-identifier hs-var hs-var">axExp0R</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Exp0R&quot;</span></span><span>    </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972812"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972812"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972812"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%5E."><span class="hs-operator hs-var">.^.</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span>
</span><span id="line-445"></span><span id="axExp1R"><span class="annot"><span class="annottext">axExp1R :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axExp1R"><span class="hs-identifier hs-var hs-var">axExp1R</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Exp1R&quot;</span></span><span>    </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972811"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972811"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972810"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972810"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972811"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%5E."><span class="hs-operator hs-var">.^.</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972810"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-446"></span><span id="axLeqRefl"><span class="annot"><span class="annottext">axLeqRefl :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axLeqRefl"><span class="hs-identifier hs-var hs-var">axLeqRefl</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;LeqRefl&quot;</span></span><span>  </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972809"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972809"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972809"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#%3C%3D%3D"><span class="hs-operator hs-var">&lt;==</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972809"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#bool"><span class="hs-identifier hs-var">bool</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span>
</span><span id="line-447"></span><span id="axCmpNatRefl"><span class="annot"><span class="annottext">axCmpNatRefl :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axCmpNatRefl"><span class="hs-identifier hs-var hs-var">axCmpNatRefl</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;CmpNatRefl&quot;</span></span><span>
</span><span id="line-448"></span><span>                </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972807"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972807"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#cmpNat"><span class="hs-identifier hs-var">cmpNat</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972807"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972807"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#ordering"><span class="hs-identifier hs-var">ordering</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">EQ</span></span><span>
</span><span id="line-449"></span><span id="axCmpSymbolRefl"><span class="annot"><span class="annottext">axCmpSymbolRefl :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axCmpSymbolRefl"><span class="hs-identifier hs-var hs-var">axCmpSymbolRefl</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;CmpSymbolRefl&quot;</span></span><span>
</span><span id="line-450"></span><span>                </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972805"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972805"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#cmpSymbol"><span class="hs-identifier hs-var">cmpSymbol</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972805"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972805"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#ordering"><span class="hs-identifier hs-var">ordering</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">EQ</span></span><span>
</span><span id="line-451"></span><span id="axLeq0L"><span class="annot"><span class="annottext">axLeq0L :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axLeq0L"><span class="hs-identifier hs-var hs-var">axLeq0L</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Leq0L&quot;</span></span><span>    </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972803"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972803"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#%3C%3D%3D"><span class="hs-operator hs-var">&lt;==</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972803"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#bool"><span class="hs-identifier hs-var">bool</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span>
</span><span id="line-452"></span><span id="axAppendSymbol0R"><span class="annot"><span class="annottext">axAppendSymbol0R :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAppendSymbol0R"><span class="hs-identifier hs-var hs-var">axAppendSymbol0R</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Concat0R&quot;</span></span><span>
</span><span id="line-453"></span><span>            </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972802"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972802"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972801"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972801"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FastString -&gt; Type
</span><a href="GHC.Core.Type.html#mkStrLitTy"><span class="hs-identifier hs-var">mkStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="GHC.Data.FastString.html#nilFS"><span class="hs-identifier hs-var">nilFS</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#appendSymbol"><span class="hs-operator hs-var">`appendSymbol`</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972802"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972801"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-454"></span><span id="axAppendSymbol0L"><span class="annot"><span class="annottext">axAppendSymbol0L :: CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAppendSymbol0L"><span class="hs-identifier hs-var hs-var">axAppendSymbol0L</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var">mkAxiom1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Concat0L&quot;</span></span><span>
</span><span id="line-455"></span><span>            </span><span class="annot"><span class="annottext">((TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule)
-&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972798"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972798"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972797"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972797"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972798"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#appendSymbol"><span class="hs-operator hs-var">`appendSymbol`</span></a></span><span> </span><span class="annot"><span class="annottext">FastString -&gt; Type
</span><a href="GHC.Core.Type.html#mkStrLitTy"><span class="hs-identifier hs-var">mkStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="GHC.Data.FastString.html#nilFS"><span class="hs-identifier hs-var">nilFS</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972797"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-456"></span><span>
</span><span id="line-457"></span><span class="hs-comment">-- The list of built-in type family axioms that GHC uses.</span><span>
</span><span id="line-458"></span><span class="hs-comment">-- If you define new axioms, make sure to include them in this list.</span><span>
</span><span id="line-459"></span><span class="hs-comment">-- See Note [Adding built-in type families]</span><span>
</span><span id="line-460"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#typeNatCoAxiomRules"><span class="hs-identifier hs-type">typeNatCoAxiomRules</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../containers/src/Data.Map.Internal.html#Map"><span class="hs-identifier hs-type">Map.Map</span></a></span><span> </span><span class="annot"><a href="GHC.Data.FastString.html#FastString"><span class="hs-identifier hs-type">FastString</span></a></span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span>
</span><span id="line-461"></span><span id="typeNatCoAxiomRules"><span class="annot"><span class="annottext">typeNatCoAxiomRules :: Map FastString CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#typeNatCoAxiomRules"><span class="hs-identifier hs-var hs-var">typeNatCoAxiomRules</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[(FastString, CoAxiomRule)] -&gt; Map FastString CoAxiomRule
forall k a. Ord k =&gt; [(k, a)] -&gt; Map k a
</span><a href="../../containers/src/Data.Map.Internal.html#fromList"><span class="hs-identifier hs-var">Map.fromList</span></a></span><span> </span><span class="annot"><span class="annottext">([(FastString, CoAxiomRule)] -&gt; Map FastString CoAxiomRule)
-&gt; [(FastString, CoAxiomRule)] -&gt; Map FastString CoAxiomRule
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule -&gt; (FastString, CoAxiomRule))
-&gt; [CoAxiomRule] -&gt; [(FastString, CoAxiomRule)]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680972795"><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="#local-6989586621680972795"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule -&gt; FastString
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrName"><span class="hs-identifier hs-var hs-var">coaxrName</span></a></span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="#local-6989586621680972795"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="#local-6989586621680972795"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-462"></span><span>  </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAddDef"><span class="hs-identifier hs-var">axAddDef</span></a></span><span>
</span><span id="line-463"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMulDef"><span class="hs-identifier hs-var">axMulDef</span></a></span><span>
</span><span id="line-464"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axExpDef"><span class="hs-identifier hs-var">axExpDef</span></a></span><span>
</span><span id="line-465"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axLeqDef"><span class="hs-identifier hs-var">axLeqDef</span></a></span><span>
</span><span id="line-466"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axCmpNatDef"><span class="hs-identifier hs-var">axCmpNatDef</span></a></span><span>
</span><span id="line-467"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axCmpSymbolDef"><span class="hs-identifier hs-var">axCmpSymbolDef</span></a></span><span>
</span><span id="line-468"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAppendSymbolDef"><span class="hs-identifier hs-var">axAppendSymbolDef</span></a></span><span>
</span><span id="line-469"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAdd0L"><span class="hs-identifier hs-var">axAdd0L</span></a></span><span>
</span><span id="line-470"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAdd0R"><span class="hs-identifier hs-var">axAdd0R</span></a></span><span>
</span><span id="line-471"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMul0L"><span class="hs-identifier hs-var">axMul0L</span></a></span><span>
</span><span id="line-472"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMul0R"><span class="hs-identifier hs-var">axMul0R</span></a></span><span>
</span><span id="line-473"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMul1L"><span class="hs-identifier hs-var">axMul1L</span></a></span><span>
</span><span id="line-474"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMul1R"><span class="hs-identifier hs-var">axMul1R</span></a></span><span>
</span><span id="line-475"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axExp1L"><span class="hs-identifier hs-var">axExp1L</span></a></span><span>
</span><span id="line-476"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axExp0R"><span class="hs-identifier hs-var">axExp0R</span></a></span><span>
</span><span id="line-477"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axExp1R"><span class="hs-identifier hs-var">axExp1R</span></a></span><span>
</span><span id="line-478"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axLeqRefl"><span class="hs-identifier hs-var">axLeqRefl</span></a></span><span>
</span><span id="line-479"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axCmpNatRefl"><span class="hs-identifier hs-var">axCmpNatRefl</span></a></span><span>
</span><span id="line-480"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axCmpSymbolRefl"><span class="hs-identifier hs-var">axCmpSymbolRefl</span></a></span><span>
</span><span id="line-481"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axLeq0L"><span class="hs-identifier hs-var">axLeq0L</span></a></span><span>
</span><span id="line-482"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axSubDef"><span class="hs-identifier hs-var">axSubDef</span></a></span><span>
</span><span id="line-483"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axSub0R"><span class="hs-identifier hs-var">axSub0R</span></a></span><span>
</span><span id="line-484"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAppendSymbol0R"><span class="hs-identifier hs-var">axAppendSymbol0R</span></a></span><span>
</span><span id="line-485"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAppendSymbol0L"><span class="hs-identifier hs-var">axAppendSymbol0L</span></a></span><span>
</span><span id="line-486"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axDivDef"><span class="hs-identifier hs-var">axDivDef</span></a></span><span>
</span><span id="line-487"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axDiv1"><span class="hs-identifier hs-var">axDiv1</span></a></span><span>
</span><span id="line-488"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axModDef"><span class="hs-identifier hs-var">axModDef</span></a></span><span>
</span><span id="line-489"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMod1"><span class="hs-identifier hs-var">axMod1</span></a></span><span>
</span><span id="line-490"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axLogDef"><span class="hs-identifier hs-var">axLogDef</span></a></span><span>
</span><span id="line-491"></span><span>  </span><span class="hs-special">]</span><span>
</span><span id="line-492"></span><span>
</span><span id="line-493"></span><span>
</span><span id="line-494"></span><span>
</span><span id="line-495"></span><span class="hs-comment">{-------------------------------------------------------------------------------
Various utilities for making axioms and types
-------------------------------------------------------------------------------}</span><span>
</span><span id="line-498"></span><span>
</span><span id="line-499"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#.%2B."><span class="hs-operator hs-type">(.+.)</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-500"></span><span id="local-6989586621680972794"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972794"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id=".%2B."><span class="annot"><span class="annottext">.+. :: Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%2B."><span class="hs-operator hs-var hs-var">.+.</span></a></span></span><span> </span><span id="local-6989586621680972793"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972793"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatAddTyCon"><span class="hs-identifier hs-var">typeNatAddTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972794"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972793"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-501"></span><span>
</span><span id="line-502"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#.-."><span class="hs-operator hs-type">(.-.)</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-503"></span><span id="local-6989586621680972792"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972792"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id=".-."><span class="annot"><span class="annottext">.-. :: Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.-."><span class="hs-operator hs-var hs-var">.-.</span></a></span></span><span> </span><span id="local-6989586621680972791"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972791"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatSubTyCon"><span class="hs-identifier hs-var">typeNatSubTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972792"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972791"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-504"></span><span>
</span><span id="line-505"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#.%2A."><span class="hs-operator hs-type">(.*.)</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-506"></span><span id="local-6989586621680972790"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972790"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id=".%2A."><span class="annot"><span class="annottext">.*. :: Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%2A."><span class="hs-operator hs-var hs-var">.*.</span></a></span></span><span> </span><span id="local-6989586621680972789"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972789"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatMulTyCon"><span class="hs-identifier hs-var">typeNatMulTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972790"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972789"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-507"></span><span>
</span><span id="line-508"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#tDiv"><span class="hs-identifier hs-type">tDiv</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-509"></span><span id="tDiv"><span class="annot"><span class="annottext">tDiv :: Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#tDiv"><span class="hs-identifier hs-var hs-var">tDiv</span></a></span></span><span> </span><span id="local-6989586621680972788"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972788"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972787"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972787"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatDivTyCon"><span class="hs-identifier hs-var">typeNatDivTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972788"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972787"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-510"></span><span>
</span><span id="line-511"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#tMod"><span class="hs-identifier hs-type">tMod</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-512"></span><span id="tMod"><span class="annot"><span class="annottext">tMod :: Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#tMod"><span class="hs-identifier hs-var hs-var">tMod</span></a></span></span><span> </span><span id="local-6989586621680972786"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972786"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972785"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972785"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatModTyCon"><span class="hs-identifier hs-var">typeNatModTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972786"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972785"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-513"></span><span>
</span><span id="line-514"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#.%5E."><span class="hs-operator hs-type">(.^.)</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-515"></span><span id="local-6989586621680972784"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972784"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id=".%5E."><span class="annot"><span class="annottext">.^. :: Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%5E."><span class="hs-operator hs-var hs-var">.^.</span></a></span></span><span> </span><span id="local-6989586621680972783"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972783"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatExpTyCon"><span class="hs-identifier hs-var">typeNatExpTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972784"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972783"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-516"></span><span>
</span><span id="line-517"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#%3C%3D%3D"><span class="hs-operator hs-type">(&lt;==)</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-518"></span><span id="local-6989586621680972782"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972782"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="%3C%3D%3D"><span class="annot"><span class="annottext">&lt;== :: Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#%3C%3D%3D"><span class="hs-operator hs-var hs-var">&lt;==</span></a></span></span><span> </span><span id="local-6989586621680972781"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972781"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatLeqTyCon"><span class="hs-identifier hs-var">typeNatLeqTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972782"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972781"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-519"></span><span>
</span><span id="line-520"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#cmpNat"><span class="hs-identifier hs-type">cmpNat</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-521"></span><span id="cmpNat"><span class="annot"><span class="annottext">cmpNat :: Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#cmpNat"><span class="hs-identifier hs-var hs-var">cmpNat</span></a></span></span><span> </span><span id="local-6989586621680972780"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972780"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972779"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972779"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeNatCmpTyCon"><span class="hs-identifier hs-var">typeNatCmpTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972780"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972779"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-522"></span><span>
</span><span id="line-523"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#cmpSymbol"><span class="hs-identifier hs-type">cmpSymbol</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-524"></span><span id="cmpSymbol"><span class="annot"><span class="annottext">cmpSymbol :: Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#cmpSymbol"><span class="hs-identifier hs-var hs-var">cmpSymbol</span></a></span></span><span> </span><span id="local-6989586621680972778"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972778"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972777"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972777"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeSymbolCmpTyCon"><span class="hs-identifier hs-var">typeSymbolCmpTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972778"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972777"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-525"></span><span>
</span><span id="line-526"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#appendSymbol"><span class="hs-identifier hs-type">appendSymbol</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-527"></span><span id="appendSymbol"><span class="annot"><span class="annottext">appendSymbol :: Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#appendSymbol"><span class="hs-identifier hs-var hs-var">appendSymbol</span></a></span></span><span> </span><span id="local-6989586621680972776"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972776"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972775"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972775"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.Literals.html#typeSymbolAppendTyCon"><span class="hs-identifier hs-var">typeSymbolAppendTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972776"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972775"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-528"></span><span>
</span><span id="line-529"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-type">(===)</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-530"></span><span id="local-6989586621680972774"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972774"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="%3D%3D%3D"><span class="annot"><span class="annottext">=== :: Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var hs-var">===</span></a></span></span><span> </span><span id="local-6989586621680972773"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972773"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
forall a. a -&gt; a -&gt; Pair a
</span><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-var">Pair</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972774"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972773"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-531"></span><span>
</span><span id="line-532"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-type">num</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-533"></span><span id="num"><span class="annot"><span class="annottext">num :: Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var hs-var">num</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Core.Type.html#mkNumLitTy"><span class="hs-identifier hs-var">mkNumLitTy</span></a></span><span>
</span><span id="line-534"></span><span>
</span><span id="line-535"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#bool"><span class="hs-identifier hs-type">bool</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-536"></span><span id="bool"><span class="annot"><span class="annottext">bool :: Bool -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#bool"><span class="hs-identifier hs-var hs-var">bool</span></a></span></span><span> </span><span id="local-6989586621680972771"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972771"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972771"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.html#promotedTrueDataCon"><span class="hs-identifier hs-var">promotedTrueDataCon</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-537"></span><span>              </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.html#promotedFalseDataCon"><span class="hs-identifier hs-var">promotedFalseDataCon</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-538"></span><span>
</span><span id="line-539"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#isBoolLitTy"><span class="hs-identifier hs-type">isBoolLitTy</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span>
</span><span id="line-540"></span><span id="isBoolLitTy"><span class="annot"><span class="annottext">isBoolLitTy :: Type -&gt; Maybe Bool
</span><a href="GHC.Builtin.Types.Literals.html#isBoolLitTy"><span class="hs-identifier hs-var hs-var">isBoolLitTy</span></a></span></span><span> </span><span id="local-6989586621680972767"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972767"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-541"></span><span>  </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">(</span><span id="local-6989586621680972766"><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680972766"><span class="hs-identifier hs-var">tc</span></a></span></span><span class="hs-special">,</span><span class="hs-special">[</span><span class="hs-special">]</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Maybe (TyCon, [Type])
Type -&gt; Maybe (TyCon, [Type])
</span><a href="GHC.Core.Type.html#splitTyConApp_maybe"><span class="hs-identifier hs-var">splitTyConApp_maybe</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972767"><span class="hs-identifier hs-var">tc</span></a></span><span>
</span><span id="line-542"></span><span>     </span><span class="hs-keyword">case</span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-543"></span><span>       </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680972766"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; TyCon -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.html#promotedFalseDataCon"><span class="hs-identifier hs-var">promotedFalseDataCon</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Maybe Bool
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span>
</span><span id="line-544"></span><span>         </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680972766"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; TyCon -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.html#promotedTrueDataCon"><span class="hs-identifier hs-var">promotedTrueDataCon</span></a></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Maybe Bool
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span>
</span><span id="line-545"></span><span>         </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>                   </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Maybe Bool
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-546"></span><span>
</span><span id="line-547"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#orderingKind"><span class="hs-identifier hs-type">orderingKind</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span>
</span><span id="line-548"></span><span id="orderingKind"><span class="annot"><span class="annottext">orderingKind :: Type
</span><a href="GHC.Builtin.Types.Literals.html#orderingKind"><span class="hs-identifier hs-var hs-var">orderingKind</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.html#orderingTyCon"><span class="hs-identifier hs-var">orderingTyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-549"></span><span>
</span><span id="line-550"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#ordering"><span class="hs-identifier hs-type">ordering</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Ordering</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-551"></span><span id="ordering"><span class="annot"><span class="annottext">ordering :: Ordering -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#ordering"><span class="hs-identifier hs-var hs-var">ordering</span></a></span></span><span> </span><span id="local-6989586621680972762"><span class="annot"><span class="annottext">Ordering
</span><a href="#local-6989586621680972762"><span class="hs-identifier hs-var">o</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-552"></span><span>  </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="#local-6989586621680972762"><span class="hs-identifier hs-var">o</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-553"></span><span>    </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">LT</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.html#promotedLTDataCon"><span class="hs-identifier hs-var">promotedLTDataCon</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-554"></span><span>    </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">EQ</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.html#promotedEQDataCon"><span class="hs-identifier hs-var">promotedEQDataCon</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-555"></span><span>    </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">GT</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.html#promotedGTDataCon"><span class="hs-identifier hs-var">promotedGTDataCon</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-556"></span><span>
</span><span id="line-557"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#isOrderingLitTy"><span class="hs-identifier hs-type">isOrderingLitTy</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Ordering</span></span><span>
</span><span id="line-558"></span><span id="isOrderingLitTy"><span class="annot"><span class="annottext">isOrderingLitTy :: Type -&gt; Maybe Ordering
</span><a href="GHC.Builtin.Types.Literals.html#isOrderingLitTy"><span class="hs-identifier hs-var hs-var">isOrderingLitTy</span></a></span></span><span> </span><span id="local-6989586621680972757"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972757"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-559"></span><span>  </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">(</span><span id="local-6989586621680972756"><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680972756"><span class="hs-identifier hs-var">tc1</span></a></span></span><span class="hs-special">,</span><span class="hs-special">[</span><span class="hs-special">]</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Maybe (TyCon, [Type])
Type -&gt; Maybe (TyCon, [Type])
</span><a href="GHC.Core.Type.html#splitTyConApp_maybe"><span class="hs-identifier hs-var">splitTyConApp_maybe</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972757"><span class="hs-identifier hs-var">tc</span></a></span><span>
</span><span id="line-560"></span><span>     </span><span class="hs-keyword">case</span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-561"></span><span>       </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680972756"><span class="hs-identifier hs-var">tc1</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; TyCon -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.html#promotedLTDataCon"><span class="hs-identifier hs-var">promotedLTDataCon</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Maybe Ordering
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">LT</span></span><span>
</span><span id="line-562"></span><span>         </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680972756"><span class="hs-identifier hs-var">tc1</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; TyCon -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.html#promotedEQDataCon"><span class="hs-identifier hs-var">promotedEQDataCon</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Maybe Ordering
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">EQ</span></span><span>
</span><span id="line-563"></span><span>         </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680972756"><span class="hs-identifier hs-var">tc1</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; TyCon -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="GHC.Builtin.Types.html#promotedGTDataCon"><span class="hs-identifier hs-var">promotedGTDataCon</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Maybe Ordering
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">GT</span></span><span>
</span><span id="line-564"></span><span>         </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>                </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Maybe Ordering
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-565"></span><span>
</span><span id="line-566"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#known"><span class="hs-identifier hs-type">known</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Utils.TcType.html#TcType"><span class="hs-identifier hs-type">TcType</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span>
</span><span id="line-567"></span><span id="known"><span class="annot"><span class="annottext">known :: (Integer -&gt; Bool) -&gt; Type -&gt; Bool
</span><a href="GHC.Builtin.Types.Literals.html#known"><span class="hs-identifier hs-var hs-var">known</span></a></span></span><span> </span><span id="local-6989586621680972754"><span class="annot"><span class="annottext">Integer -&gt; Bool
</span><a href="#local-6989586621680972754"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621680972753"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972753"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972753"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-568"></span><span>              </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972751"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972751"><span class="hs-identifier hs-var">a</span></a></span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Bool
</span><a href="#local-6989586621680972754"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972751"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-569"></span><span>              </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span>
</span><span id="line-570"></span><span>
</span><span id="line-571"></span><span>
</span><span id="line-572"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#mkUnAxiom"><span class="hs-identifier hs-type">mkUnAxiom</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span>
</span><span id="line-573"></span><span id="mkUnAxiom"><span class="annot"><span class="annottext">mkUnAxiom :: String -&gt; TyCon -&gt; (Integer -&gt; Maybe Type) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkUnAxiom"><span class="hs-identifier hs-var hs-var">mkUnAxiom</span></a></span></span><span> </span><span id="local-6989586621680972750"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972750"><span class="hs-identifier hs-var">str</span></a></span></span><span> </span><span id="local-6989586621680972749"><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680972749"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621680972748"><span class="annot"><span class="annottext">Integer -&gt; Maybe Type
</span><a href="#local-6989586621680972748"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-574"></span><span>  </span><span class="annot"><span class="annottext">CoAxiomRule :: FastString
-&gt; [Role] -&gt; Role -&gt; ([TypeEqn] -&gt; Maybe TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span>
</span><span id="line-575"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">coaxrName :: FastString
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrName"><span class="hs-identifier hs-var">coaxrName</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972750"><span class="hs-identifier hs-var">str</span></a></span><span>
</span><span id="line-576"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrAsmpRoles :: [Role]
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrAsmpRoles"><span class="hs-identifier hs-var">coaxrAsmpRoles</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-577"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrRole :: Role
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrRole"><span class="hs-identifier hs-var">coaxrRole</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span>
</span><span id="line-578"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrProves :: [TypeEqn] -&gt; Maybe TypeEqn
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrProves"><span class="hs-identifier hs-var">coaxrProves</span></a></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680972747"><span class="annot"><span class="annottext">[TypeEqn]
</span><a href="#local-6989586621680972747"><span class="hs-identifier hs-var">cs</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-579"></span><span>        </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972746"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972746"><span class="hs-identifier hs-var">s1</span></a></span></span><span> </span><span id="local-6989586621680972745"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972745"><span class="hs-identifier hs-var">s2</span></a></span></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[TypeEqn] -&gt; Maybe [TypeEqn]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">[TypeEqn]
</span><a href="#local-6989586621680972747"><span class="hs-identifier hs-var">cs</span></a></span><span>
</span><span id="line-580"></span><span>           </span><span id="local-6989586621680972744"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972744"><span class="hs-identifier hs-var">s2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972745"><span class="hs-identifier hs-var">s2</span></a></span><span>
</span><span id="line-581"></span><span>           </span><span id="local-6989586621680972743"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972743"><span class="hs-identifier hs-var">z</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Maybe Type
</span><a href="#local-6989586621680972748"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972744"><span class="hs-identifier hs-var">s2'</span></a></span><span>
</span><span id="line-582"></span><span>           </span><span class="annot"><span class="annottext">TypeEqn -&gt; Maybe TypeEqn
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680972749"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972746"><span class="hs-identifier hs-var">s1</span></a></span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972743"><span class="hs-identifier hs-var">z</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-583"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-584"></span><span>
</span><span id="line-585"></span><span>
</span><span id="line-586"></span><span>
</span><span id="line-587"></span><span class="hs-comment">-- For the definitional axioms</span><span>
</span><span id="line-588"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#mkBinAxiom"><span class="hs-identifier hs-type">mkBinAxiom</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.TyCon.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-589"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span>
</span><span id="line-590"></span><span id="mkBinAxiom"><span class="annot"><span class="annottext">mkBinAxiom :: String
-&gt; TyCon -&gt; (Integer -&gt; Integer -&gt; Maybe Type) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkBinAxiom"><span class="hs-identifier hs-var hs-var">mkBinAxiom</span></a></span></span><span> </span><span id="local-6989586621680972742"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972742"><span class="hs-identifier hs-var">str</span></a></span></span><span> </span><span id="local-6989586621680972741"><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680972741"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621680972740"><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe Type
</span><a href="#local-6989586621680972740"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-591"></span><span>  </span><span class="annot"><span class="annottext">CoAxiomRule :: FastString
-&gt; [Role] -&gt; Role -&gt; ([TypeEqn] -&gt; Maybe TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span>
</span><span id="line-592"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">coaxrName :: FastString
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrName"><span class="hs-identifier hs-var">coaxrName</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972742"><span class="hs-identifier hs-var">str</span></a></span><span>
</span><span id="line-593"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrAsmpRoles :: [Role]
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrAsmpRoles"><span class="hs-identifier hs-var">coaxrAsmpRoles</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-594"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrRole :: Role
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrRole"><span class="hs-identifier hs-var">coaxrRole</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span>
</span><span id="line-595"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrProves :: [TypeEqn] -&gt; Maybe TypeEqn
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrProves"><span class="hs-identifier hs-var">coaxrProves</span></a></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680972739"><span class="annot"><span class="annottext">[TypeEqn]
</span><a href="#local-6989586621680972739"><span class="hs-identifier hs-var">cs</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-596"></span><span>        </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972738"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972738"><span class="hs-identifier hs-var">s1</span></a></span></span><span> </span><span id="local-6989586621680972737"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972737"><span class="hs-identifier hs-var">s2</span></a></span></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span id="local-6989586621680972736"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972736"><span class="hs-identifier hs-var">t1</span></a></span></span><span> </span><span id="local-6989586621680972735"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972735"><span class="hs-identifier hs-var">t2</span></a></span></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[TypeEqn] -&gt; Maybe [TypeEqn]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">[TypeEqn]
</span><a href="#local-6989586621680972739"><span class="hs-identifier hs-var">cs</span></a></span><span>
</span><span id="line-597"></span><span>           </span><span id="local-6989586621680972734"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972734"><span class="hs-identifier hs-var">s2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972737"><span class="hs-identifier hs-var">s2</span></a></span><span>
</span><span id="line-598"></span><span>           </span><span id="local-6989586621680972733"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972733"><span class="hs-identifier hs-var">t2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972735"><span class="hs-identifier hs-var">t2</span></a></span><span>
</span><span id="line-599"></span><span>           </span><span id="local-6989586621680972732"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972732"><span class="hs-identifier hs-var">z</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe Type
</span><a href="#local-6989586621680972740"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972734"><span class="hs-identifier hs-var">s2'</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972733"><span class="hs-identifier hs-var">t2'</span></a></span><span>
</span><span id="line-600"></span><span>           </span><span class="annot"><span class="annottext">TypeEqn -&gt; Maybe TypeEqn
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; [Type] -&gt; Type
</span><a href="GHC.Core.TyCo.Rep.html#mkTyConApp"><span class="hs-identifier hs-var">mkTyConApp</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680972741"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972738"><span class="hs-identifier hs-var">s1</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972736"><span class="hs-identifier hs-var">t1</span></a></span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972732"><span class="hs-identifier hs-var">z</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-601"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-602"></span><span>
</span><span id="line-603"></span><span>
</span><span id="line-604"></span><span>
</span><span id="line-605"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-type">mkAxiom1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#TypeEqn"><span class="hs-identifier hs-type">TypeEqn</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#TypeEqn"><span class="hs-identifier hs-type">TypeEqn</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span>
</span><span id="line-606"></span><span id="mkAxiom1"><span class="annot"><span class="annottext">mkAxiom1 :: String -&gt; (TypeEqn -&gt; TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#mkAxiom1"><span class="hs-identifier hs-var hs-var">mkAxiom1</span></a></span></span><span> </span><span id="local-6989586621680972731"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972731"><span class="hs-identifier hs-var">str</span></a></span></span><span> </span><span id="local-6989586621680972730"><span class="annot"><span class="annottext">TypeEqn -&gt; TypeEqn
</span><a href="#local-6989586621680972730"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-607"></span><span>  </span><span class="annot"><span class="annottext">CoAxiomRule :: FastString
-&gt; [Role] -&gt; Role -&gt; ([TypeEqn] -&gt; Maybe TypeEqn) -&gt; CoAxiomRule
</span><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span>
</span><span id="line-608"></span><span>    </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">coaxrName :: FastString
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrName"><span class="hs-identifier hs-var">coaxrName</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#fsLit"><span class="hs-identifier hs-var">fsLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972731"><span class="hs-identifier hs-var">str</span></a></span><span>
</span><span id="line-609"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrAsmpRoles :: [Role]
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrAsmpRoles"><span class="hs-identifier hs-var">coaxrAsmpRoles</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-610"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrRole :: Role
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrRole"><span class="hs-identifier hs-var">coaxrRole</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Role
</span><a href="GHC.Core.Coercion.Axiom.html#Nominal"><span class="hs-identifier hs-var">Nominal</span></a></span><span>
</span><span id="line-611"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">coaxrProves :: [TypeEqn] -&gt; Maybe TypeEqn
</span><a href="GHC.Core.Coercion.Axiom.html#coaxrProves"><span class="hs-identifier hs-var">coaxrProves</span></a></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span class="hs-glyph">case</span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972729"><span class="annot"><span class="annottext">TypeEqn
</span><a href="#local-6989586621680972729"><span class="hs-identifier hs-var">eqn</span></a></span></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TypeEqn -&gt; Maybe TypeEqn
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeEqn -&gt; TypeEqn
</span><a href="#local-6989586621680972730"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">TypeEqn
</span><a href="#local-6989586621680972729"><span class="hs-identifier hs-var">eqn</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-612"></span><span>                             </span><span class="annot"><span class="annottext">[TypeEqn]
</span><span class="hs-identifier">_</span></span><span>     </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Maybe TypeEqn
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-613"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-614"></span><span>
</span><span id="line-615"></span><span>
</span><span id="line-616"></span><span class="hs-comment">{-------------------------------------------------------------------------------
Evaluation
-------------------------------------------------------------------------------}</span><span>
</span><span id="line-619"></span><span>
</span><span id="line-620"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamAdd"><span class="hs-identifier hs-type">matchFamAdd</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-621"></span><span id="matchFamAdd"><span class="annot"><span class="annottext">matchFamAdd :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamAdd"><span class="hs-identifier hs-var hs-var">matchFamAdd</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972728"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972728"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972727"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972727"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span>
</span><span id="line-622"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972726"><span class="hs-identifier hs-var">mbX</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAdd0L"><span class="hs-identifier hs-var">axAdd0L</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972727"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972727"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-623"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972725"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAdd0R"><span class="hs-identifier hs-var">axAdd0R</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972728"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972728"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-624"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972724"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972724"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972726"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972723"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972723"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972725"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-625"></span><span>    </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAddDef"><span class="hs-identifier hs-var">axAddDef</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972728"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972727"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972724"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972723"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-626"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972726"><span class="annot"><span class="annottext">mbX :: Maybe Integer
</span><a href="#local-6989586621680972726"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972728"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-627"></span><span>        </span><span id="local-6989586621680972725"><span class="annot"><span class="annottext">mbY :: Maybe Integer
</span><a href="#local-6989586621680972725"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972727"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-628"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamAdd"><span class="hs-identifier hs-var">matchFamAdd</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (CoAxiomRule, [Type], Type)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-629"></span><span>
</span><span id="line-630"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamSub"><span class="hs-identifier hs-type">matchFamSub</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-631"></span><span id="matchFamSub"><span class="annot"><span class="annottext">matchFamSub :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamSub"><span class="hs-identifier hs-var hs-var">matchFamSub</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972722"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972722"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972721"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972721"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span>
</span><span id="line-632"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972720"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axSub0R"><span class="hs-identifier hs-var">axSub0R</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972722"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972722"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-633"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972719"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972719"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972718"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972717"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972717"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972720"><span class="hs-identifier hs-var">mbY</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972716"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972716"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe Integer
</span><a href="GHC.Builtin.Types.Literals.html#minus"><span class="hs-identifier hs-var">minus</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972719"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972717"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-634"></span><span>    </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axSubDef"><span class="hs-identifier hs-var">axSubDef</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972722"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972721"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972716"><span class="hs-identifier hs-var">z</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-635"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972718"><span class="annot"><span class="annottext">mbX :: Maybe Integer
</span><a href="#local-6989586621680972718"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972722"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-636"></span><span>        </span><span id="local-6989586621680972720"><span class="annot"><span class="annottext">mbY :: Maybe Integer
</span><a href="#local-6989586621680972720"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972721"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-637"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamSub"><span class="hs-identifier hs-var">matchFamSub</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (CoAxiomRule, [Type], Type)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-638"></span><span>
</span><span id="line-639"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamMul"><span class="hs-identifier hs-type">matchFamMul</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-640"></span><span id="matchFamMul"><span class="annot"><span class="annottext">matchFamMul :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamMul"><span class="hs-identifier hs-var hs-var">matchFamMul</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972715"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972715"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972714"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972714"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span>
</span><span id="line-641"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972713"><span class="hs-identifier hs-var">mbX</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMul0L"><span class="hs-identifier hs-var">axMul0L</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972714"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-642"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972712"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMul0R"><span class="hs-identifier hs-var">axMul0R</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972715"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-643"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972713"><span class="hs-identifier hs-var">mbX</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMul1L"><span class="hs-identifier hs-var">axMul1L</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972714"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972714"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-644"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972712"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMul1R"><span class="hs-identifier hs-var">axMul1R</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972715"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972715"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-645"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972711"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972711"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972713"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972710"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972710"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972712"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-646"></span><span>    </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMulDef"><span class="hs-identifier hs-var">axMulDef</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972715"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972714"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972711"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972710"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-647"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972713"><span class="annot"><span class="annottext">mbX :: Maybe Integer
</span><a href="#local-6989586621680972713"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972715"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-648"></span><span>        </span><span id="local-6989586621680972712"><span class="annot"><span class="annottext">mbY :: Maybe Integer
</span><a href="#local-6989586621680972712"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972714"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-649"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamMul"><span class="hs-identifier hs-var">matchFamMul</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (CoAxiomRule, [Type], Type)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-650"></span><span>
</span><span id="line-651"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamDiv"><span class="hs-identifier hs-type">matchFamDiv</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-652"></span><span id="matchFamDiv"><span class="annot"><span class="annottext">matchFamDiv :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamDiv"><span class="hs-identifier hs-var hs-var">matchFamDiv</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972709"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972709"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972708"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972708"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span>
</span><span id="line-653"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972707"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axDiv1"><span class="hs-identifier hs-var">axDiv1</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972709"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972709"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-654"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972706"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972706"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972705"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972704"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972704"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972707"><span class="hs-identifier hs-var">mbY</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972704"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axDivDef"><span class="hs-identifier hs-var">axDivDef</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972709"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972708"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#div"><span class="hs-identifier hs-var">div</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972706"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972704"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-655"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972705"><span class="annot"><span class="annottext">mbX :: Maybe Integer
</span><a href="#local-6989586621680972705"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972709"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-656"></span><span>        </span><span id="local-6989586621680972707"><span class="annot"><span class="annottext">mbY :: Maybe Integer
</span><a href="#local-6989586621680972707"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972708"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-657"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamDiv"><span class="hs-identifier hs-var">matchFamDiv</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (CoAxiomRule, [Type], Type)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-658"></span><span>
</span><span id="line-659"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamMod"><span class="hs-identifier hs-type">matchFamMod</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-660"></span><span id="matchFamMod"><span class="annot"><span class="annottext">matchFamMod :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamMod"><span class="hs-identifier hs-var hs-var">matchFamMod</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972703"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972703"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972702"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972702"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span>
</span><span id="line-661"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972701"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axMod1"><span class="hs-identifier hs-var">axMod1</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972703"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-662"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972700"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972700"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972699"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972698"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972698"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972701"><span class="hs-identifier hs-var">mbY</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972698"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axModDef"><span class="hs-identifier hs-var">axModDef</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972703"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972702"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#mod"><span class="hs-identifier hs-var">mod</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972700"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972698"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-663"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972699"><span class="annot"><span class="annottext">mbX :: Maybe Integer
</span><a href="#local-6989586621680972699"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972703"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-664"></span><span>        </span><span id="local-6989586621680972701"><span class="annot"><span class="annottext">mbY :: Maybe Integer
</span><a href="#local-6989586621680972701"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972702"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-665"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamMod"><span class="hs-identifier hs-var">matchFamMod</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (CoAxiomRule, [Type], Type)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-666"></span><span>
</span><span id="line-667"></span><span>
</span><span id="line-668"></span><span>
</span><span id="line-669"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamExp"><span class="hs-identifier hs-type">matchFamExp</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-670"></span><span id="matchFamExp"><span class="annot"><span class="annottext">matchFamExp :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamExp"><span class="hs-identifier hs-var hs-var">matchFamExp</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972697"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972697"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972696"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972696"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span>
</span><span id="line-671"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972695"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axExp0R"><span class="hs-identifier hs-var">axExp0R</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972697"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span>
</span><span id="line-672"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972694"><span class="hs-identifier hs-var">mbX</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axExp1L"><span class="hs-identifier hs-var">axExp1L</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972696"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span>
</span><span id="line-673"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972695"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axExp1R"><span class="hs-identifier hs-var">axExp1R</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972697"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972697"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-674"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972693"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972693"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972694"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972692"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972692"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972695"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-675"></span><span>    </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axExpDef"><span class="hs-identifier hs-var">axExpDef</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972697"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972696"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972693"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a b. (Num a, Integral b) =&gt; a -&gt; b -&gt; a
</span><a href="../../base/src/GHC.Real.html#%5E"><span class="hs-operator hs-var">^</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972692"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-676"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972694"><span class="annot"><span class="annottext">mbX :: Maybe Integer
</span><a href="#local-6989586621680972694"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972697"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-677"></span><span>        </span><span id="local-6989586621680972695"><span class="annot"><span class="annottext">mbY :: Maybe Integer
</span><a href="#local-6989586621680972695"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972696"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-678"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamExp"><span class="hs-identifier hs-var">matchFamExp</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (CoAxiomRule, [Type], Type)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-679"></span><span>
</span><span id="line-680"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamLog"><span class="hs-identifier hs-type">matchFamLog</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-681"></span><span id="matchFamLog"><span class="annot"><span class="annottext">matchFamLog :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamLog"><span class="hs-identifier hs-var hs-var">matchFamLog</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972691"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972691"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">]</span><span>
</span><span id="line-682"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972690"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972690"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972689"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="hs-special">(</span><span id="local-6989586621680972688"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972688"><span class="hs-identifier hs-var">n</span></a></span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe (Integer, Bool)
</span><a href="GHC.Builtin.Types.Literals.html#genLog"><span class="hs-identifier hs-var">genLog</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972690"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axLogDef"><span class="hs-identifier hs-var">axLogDef</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972691"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972688"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-683"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972689"><span class="annot"><span class="annottext">mbX :: Maybe Integer
</span><a href="#local-6989586621680972689"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972691"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-684"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamLog"><span class="hs-identifier hs-var">matchFamLog</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (CoAxiomRule, [Type], Type)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-685"></span><span>
</span><span id="line-686"></span><span>
</span><span id="line-687"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamLeq"><span class="hs-identifier hs-type">matchFamLeq</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-688"></span><span id="matchFamLeq"><span class="annot"><span class="annottext">matchFamLeq :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamLeq"><span class="hs-identifier hs-var hs-var">matchFamLeq</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972687"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972687"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972686"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972686"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span>
</span><span id="line-689"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972685"><span class="hs-identifier hs-var">mbX</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axLeq0L"><span class="hs-identifier hs-var">axLeq0L</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972686"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#bool"><span class="hs-identifier hs-var">bool</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-special">)</span><span>
</span><span id="line-690"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972684"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972684"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972685"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972683"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972683"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972682"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-691"></span><span>    </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axLeqDef"><span class="hs-identifier hs-var">axLeqDef</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972687"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972686"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#bool"><span class="hs-identifier hs-var">bool</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972684"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972683"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-692"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972687"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972686"><span class="hs-identifier hs-var">t</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axLeqRefl"><span class="hs-identifier hs-var">axLeqRefl</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972687"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#bool"><span class="hs-identifier hs-var">bool</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-special">)</span><span>
</span><span id="line-693"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972685"><span class="annot"><span class="annottext">mbX :: Maybe Integer
</span><a href="#local-6989586621680972685"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972687"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-694"></span><span>        </span><span id="local-6989586621680972682"><span class="annot"><span class="annottext">mbY :: Maybe Integer
</span><a href="#local-6989586621680972682"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972686"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-695"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamLeq"><span class="hs-identifier hs-var">matchFamLeq</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (CoAxiomRule, [Type], Type)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-696"></span><span>
</span><span id="line-697"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamCmpNat"><span class="hs-identifier hs-type">matchFamCmpNat</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-698"></span><span id="matchFamCmpNat"><span class="annot"><span class="annottext">matchFamCmpNat :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamCmpNat"><span class="hs-identifier hs-var hs-var">matchFamCmpNat</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972681"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972681"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972680"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972680"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span>
</span><span id="line-699"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972679"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972679"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972678"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972677"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972677"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972676"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-700"></span><span>    </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axCmpNatDef"><span class="hs-identifier hs-var">axCmpNatDef</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972681"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972680"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#ordering"><span class="hs-identifier hs-var">ordering</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><span class="hs-identifier hs-var">compare</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972679"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972677"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-701"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972681"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972680"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axCmpNatRefl"><span class="hs-identifier hs-var">axCmpNatRefl</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972681"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#ordering"><span class="hs-identifier hs-var">ordering</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">EQ</span></span><span class="hs-special">)</span><span>
</span><span id="line-702"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972678"><span class="annot"><span class="annottext">mbX :: Maybe Integer
</span><a href="#local-6989586621680972678"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972681"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-703"></span><span>        </span><span id="local-6989586621680972676"><span class="annot"><span class="annottext">mbY :: Maybe Integer
</span><a href="#local-6989586621680972676"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972680"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-704"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamCmpNat"><span class="hs-identifier hs-var">matchFamCmpNat</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (CoAxiomRule, [Type], Type)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-705"></span><span>
</span><span id="line-706"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamCmpSymbol"><span class="hs-identifier hs-type">matchFamCmpSymbol</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-707"></span><span id="matchFamCmpSymbol"><span class="annot"><span class="annottext">matchFamCmpSymbol :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamCmpSymbol"><span class="hs-identifier hs-var hs-var">matchFamCmpSymbol</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972675"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972675"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972674"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972674"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span>
</span><span id="line-708"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972673"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972673"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe FastString
</span><a href="#local-6989586621680972672"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972671"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972671"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe FastString
</span><a href="#local-6989586621680972670"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-709"></span><span>    </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axCmpSymbolDef"><span class="hs-identifier hs-var">axCmpSymbolDef</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972675"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972674"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#ordering"><span class="hs-identifier hs-var">ordering</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FastString -&gt; FastString -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><span class="hs-identifier hs-var">compare</span></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972673"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972671"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-710"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972675"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972674"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axCmpSymbolRefl"><span class="hs-identifier hs-var">axCmpSymbolRefl</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972675"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#ordering"><span class="hs-identifier hs-var">ordering</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">EQ</span></span><span class="hs-special">)</span><span>
</span><span id="line-711"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972672"><span class="annot"><span class="annottext">mbX :: Maybe FastString
</span><a href="#local-6989586621680972672"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe FastString
</span><a href="GHC.Core.Type.html#isStrLitTy"><span class="hs-identifier hs-var">isStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972675"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-712"></span><span>        </span><span id="local-6989586621680972670"><span class="annot"><span class="annottext">mbY :: Maybe FastString
</span><a href="#local-6989586621680972670"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe FastString
</span><a href="GHC.Core.Type.html#isStrLitTy"><span class="hs-identifier hs-var">isStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972674"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-713"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamCmpSymbol"><span class="hs-identifier hs-var">matchFamCmpSymbol</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (CoAxiomRule, [Type], Type)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-714"></span><span>
</span><span id="line-715"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamAppendSymbol"><span class="hs-identifier hs-type">matchFamAppendSymbol</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Core.Coercion.Axiom.html#CoAxiomRule"><span class="hs-identifier hs-type">CoAxiomRule</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-716"></span><span id="matchFamAppendSymbol"><span class="annot"><span class="annottext">matchFamAppendSymbol :: [Type] -&gt; Maybe (CoAxiomRule, [Type], Type)
</span><a href="GHC.Builtin.Types.Literals.html#matchFamAppendSymbol"><span class="hs-identifier hs-var hs-var">matchFamAppendSymbol</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972669"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972669"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972668"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972668"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span>
</span><span id="line-717"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972667"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972667"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe FastString
</span><a href="#local-6989586621680972666"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">FastString -&gt; Bool
</span><a href="GHC.Data.FastString.html#nullFS"><span class="hs-identifier hs-var">nullFS</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972667"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAppendSymbol0R"><span class="hs-identifier hs-var">axAppendSymbol0R</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972668"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972668"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-718"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972664"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972664"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe FastString
</span><a href="#local-6989586621680972663"><span class="hs-identifier hs-var">mbY</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">FastString -&gt; Bool
</span><a href="GHC.Data.FastString.html#nullFS"><span class="hs-identifier hs-var">nullFS</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972664"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAppendSymbol0L"><span class="hs-identifier hs-var">axAppendSymbol0L</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972669"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972669"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-719"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972662"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972662"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe FastString
</span><a href="#local-6989586621680972666"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972661"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972661"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe FastString
</span><a href="#local-6989586621680972663"><span class="hs-identifier hs-var">mbY</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-720"></span><span>    </span><span class="annot"><span class="annottext">(CoAxiomRule, [Type], Type) -&gt; Maybe (CoAxiomRule, [Type], Type)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">CoAxiomRule
</span><a href="GHC.Builtin.Types.Literals.html#axAppendSymbolDef"><span class="hs-identifier hs-var">axAppendSymbolDef</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972669"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972668"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">FastString -&gt; Type
</span><a href="GHC.Core.Type.html#mkStrLitTy"><span class="hs-identifier hs-var">mkStrLitTy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FastString -&gt; FastString -&gt; FastString
</span><a href="GHC.Data.FastString.html#appendFS"><span class="hs-identifier hs-var">appendFS</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972662"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972661"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-721"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-722"></span><span>  </span><span id="local-6989586621680972666"><span class="annot"><span class="annottext">mbX :: Maybe FastString
</span><a href="#local-6989586621680972666"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe FastString
</span><a href="GHC.Core.Type.html#isStrLitTy"><span class="hs-identifier hs-var">isStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972669"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-723"></span><span>  </span><span id="local-6989586621680972663"><span class="annot"><span class="annottext">mbY :: Maybe FastString
</span><a href="#local-6989586621680972663"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe FastString
</span><a href="GHC.Core.Type.html#isStrLitTy"><span class="hs-identifier hs-var">isStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972668"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-724"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#matchFamAppendSymbol"><span class="hs-identifier hs-var">matchFamAppendSymbol</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (CoAxiomRule, [Type], Type)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-725"></span><span>
</span><span id="line-726"></span><span class="hs-comment">{-------------------------------------------------------------------------------
Interact with axioms
-------------------------------------------------------------------------------}</span><span>
</span><span id="line-729"></span><span>
</span><span id="line-730"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopAdd"><span class="hs-identifier hs-type">interactTopAdd</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-731"></span><span id="interactTopAdd"><span class="annot"><span class="annottext">interactTopAdd :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopAdd"><span class="hs-identifier hs-var hs-var">interactTopAdd</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972660"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972660"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972659"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972659"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972658"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972658"><span class="hs-identifier hs-var">r</span></a></span></span><span>
</span><span id="line-732"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972657"><span class="hs-identifier hs-var">mbZ</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972660"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972659"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-special">]</span><span>                          </span><span class="hs-comment">-- (s + t ~ 0) =&gt; (s ~ 0, t ~ 0)</span><span>
</span><span id="line-733"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972656"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972656"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972655"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972654"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972654"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972657"><span class="hs-identifier hs-var">mbZ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972653"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972653"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe Integer
</span><a href="GHC.Builtin.Types.Literals.html#minus"><span class="hs-identifier hs-var">minus</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972654"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972656"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972659"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972653"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">]</span><span>     </span><span class="hs-comment">-- (5 + t ~ 8) =&gt; (t ~ 3)</span><span>
</span><span id="line-734"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972652"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972652"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972651"><span class="hs-identifier hs-var">mbY</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972650"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972650"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972657"><span class="hs-identifier hs-var">mbZ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972649"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972649"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe Integer
</span><a href="GHC.Builtin.Types.Literals.html#minus"><span class="hs-identifier hs-var">minus</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972650"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972652"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972660"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972649"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">]</span><span>     </span><span class="hs-comment">-- (s + 5 ~ 8) =&gt; (s ~ 3)</span><span>
</span><span id="line-735"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-736"></span><span>  </span><span id="local-6989586621680972655"><span class="annot"><span class="annottext">mbX :: Maybe Integer
</span><a href="#local-6989586621680972655"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972660"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-737"></span><span>  </span><span id="local-6989586621680972651"><span class="annot"><span class="annottext">mbY :: Maybe Integer
</span><a href="#local-6989586621680972651"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972659"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-738"></span><span>  </span><span id="local-6989586621680972657"><span class="annot"><span class="annottext">mbZ :: Maybe Integer
</span><a href="#local-6989586621680972657"><span class="hs-identifier hs-var hs-var">mbZ</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972658"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-739"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopAdd"><span class="hs-identifier hs-var">interactTopAdd</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-740"></span><span>
</span><span id="line-741"></span><span class="hs-comment">{-
Note [Weakened interaction rule for subtraction]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

A simpler interaction here might be:

  `s - t ~ r` --&gt; `t + r ~ s`

This would enable us to reuse all the code for addition.
Unfortunately, this works a little too well at the moment.
Consider the following example:

    0 - 5 ~ r --&gt; 5 + r ~ 0 --&gt; (5 = 0, r = 0)

This (correctly) spots that the constraint cannot be solved.

However, this may be a problem if the constraint did not
need to be solved in the first place!  Consider the following example:

f :: Proxy (If (5 &lt;=? 0) (0 - 5) (5 - 0)) -&gt; Proxy 5
f = id

Currently, GHC is strict while evaluating functions, so this does not
work, because even though the `If` should evaluate to `5 - 0`, we
also evaluate the &quot;then&quot; branch which generates the constraint `0 - 5 ~ r`,
which fails.

So, for the time being, we only add an improvement when the RHS is a constant,
which happens to work OK for the moment, although clearly we need to do
something more general.
-}</span><span>
</span><span id="line-772"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopSub"><span class="hs-identifier hs-type">interactTopSub</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-773"></span><span id="interactTopSub"><span class="annot"><span class="annottext">interactTopSub :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopSub"><span class="hs-identifier hs-var hs-var">interactTopSub</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972648"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972648"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972647"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972647"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972646"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972646"><span class="hs-identifier hs-var">r</span></a></span></span><span>
</span><span id="line-774"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972645"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972645"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972644"><span class="hs-identifier hs-var">mbZ</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972648"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972645"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#.%2B."><span class="hs-operator hs-var">.+.</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972647"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">]</span><span>         </span><span class="hs-comment">-- (s - t ~ 5) =&gt; (5 + t ~ s)</span><span>
</span><span id="line-775"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-776"></span><span>  </span><span id="local-6989586621680972644"><span class="annot"><span class="annottext">mbZ :: Maybe Integer
</span><a href="#local-6989586621680972644"><span class="hs-identifier hs-var hs-var">mbZ</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972646"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-777"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopSub"><span class="hs-identifier hs-var">interactTopSub</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-778"></span><span>
</span><span id="line-779"></span><span>
</span><span id="line-780"></span><span>
</span><span id="line-781"></span><span>
</span><span id="line-782"></span><span>
</span><span id="line-783"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopMul"><span class="hs-identifier hs-type">interactTopMul</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-784"></span><span id="interactTopMul"><span class="annot"><span class="annottext">interactTopMul :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopMul"><span class="hs-identifier hs-var hs-var">interactTopMul</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972643"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972643"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972642"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972642"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972641"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972641"><span class="hs-identifier hs-var">r</span></a></span></span><span>
</span><span id="line-785"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972640"><span class="hs-identifier hs-var">mbZ</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972643"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972642"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span> </span><span class="hs-special">]</span><span>                        </span><span class="hs-comment">-- (s * t ~ 1)  =&gt; (s ~ 1, t ~ 1)</span><span>
</span><span id="line-786"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972639"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972639"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972638"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972637"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972637"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972640"><span class="hs-identifier hs-var">mbZ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972636"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972636"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe Integer
</span><a href="GHC.Builtin.Types.Literals.html#divide"><span class="hs-identifier hs-var">divide</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972637"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972639"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972642"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972636"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">]</span><span>  </span><span class="hs-comment">-- (3 * t ~ 15) =&gt; (t ~ 5)</span><span>
</span><span id="line-787"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972634"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972634"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972633"><span class="hs-identifier hs-var">mbY</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972632"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972632"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972640"><span class="hs-identifier hs-var">mbZ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972631"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972631"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe Integer
</span><a href="GHC.Builtin.Types.Literals.html#divide"><span class="hs-identifier hs-var">divide</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972632"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972634"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972643"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972631"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">]</span><span>  </span><span class="hs-comment">-- (s * 3 ~ 15) =&gt; (s ~ 5)</span><span>
</span><span id="line-788"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-789"></span><span>  </span><span id="local-6989586621680972638"><span class="annot"><span class="annottext">mbX :: Maybe Integer
</span><a href="#local-6989586621680972638"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972643"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-790"></span><span>  </span><span id="local-6989586621680972633"><span class="annot"><span class="annottext">mbY :: Maybe Integer
</span><a href="#local-6989586621680972633"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972642"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-791"></span><span>  </span><span id="local-6989586621680972640"><span class="annot"><span class="annottext">mbZ :: Maybe Integer
</span><a href="#local-6989586621680972640"><span class="hs-identifier hs-var hs-var">mbZ</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972641"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-792"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopMul"><span class="hs-identifier hs-var">interactTopMul</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-793"></span><span>
</span><span id="line-794"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopDiv"><span class="hs-identifier hs-type">interactTopDiv</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-795"></span><span id="interactTopDiv"><span class="annot"><span class="annottext">interactTopDiv :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopDiv"><span class="hs-identifier hs-var hs-var">interactTopDiv</span></a></span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>   </span><span class="hs-comment">-- I can't think of anything...</span><span>
</span><span id="line-796"></span><span>
</span><span id="line-797"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopMod"><span class="hs-identifier hs-type">interactTopMod</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-798"></span><span id="interactTopMod"><span class="annot"><span class="annottext">interactTopMod :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopMod"><span class="hs-identifier hs-var hs-var">interactTopMod</span></a></span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>   </span><span class="hs-comment">-- I can't think of anything...</span><span>
</span><span id="line-799"></span><span>
</span><span id="line-800"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopExp"><span class="hs-identifier hs-type">interactTopExp</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-801"></span><span id="interactTopExp"><span class="annot"><span class="annottext">interactTopExp :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopExp"><span class="hs-identifier hs-var hs-var">interactTopExp</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972630"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972630"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972629"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972629"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972628"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972628"><span class="hs-identifier hs-var">r</span></a></span></span><span>
</span><span id="line-802"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972627"><span class="hs-identifier hs-var">mbZ</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972630"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-special">]</span><span>                                       </span><span class="hs-comment">-- (s ^ t ~ 0) =&gt; (s ~ 0)</span><span>
</span><span id="line-803"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972626"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972626"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972625"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972624"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972624"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972627"><span class="hs-identifier hs-var">mbZ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972623"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972623"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe Integer
</span><a href="GHC.Builtin.Types.Literals.html#logExact"><span class="hs-identifier hs-var">logExact</span></a></span><span>  </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972624"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972626"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972629"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972623"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-comment">-- (2 ^ t ~ 8) =&gt; (t ~ 3)</span><span>
</span><span id="line-804"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972621"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972621"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972620"><span class="hs-identifier hs-var">mbY</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972619"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972619"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972627"><span class="hs-identifier hs-var">mbZ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972618"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972618"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe Integer
</span><a href="GHC.Builtin.Types.Literals.html#rootExact"><span class="hs-identifier hs-var">rootExact</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972619"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972621"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972630"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972618"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-comment">-- (s ^ 2 ~ 9) =&gt; (s ~ 3)</span><span>
</span><span id="line-805"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-806"></span><span>  </span><span id="local-6989586621680972625"><span class="annot"><span class="annottext">mbX :: Maybe Integer
</span><a href="#local-6989586621680972625"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972630"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-807"></span><span>  </span><span id="local-6989586621680972620"><span class="annot"><span class="annottext">mbY :: Maybe Integer
</span><a href="#local-6989586621680972620"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972629"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-808"></span><span>  </span><span id="local-6989586621680972627"><span class="annot"><span class="annottext">mbZ :: Maybe Integer
</span><a href="#local-6989586621680972627"><span class="hs-identifier hs-var hs-var">mbZ</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972628"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-809"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopExp"><span class="hs-identifier hs-var">interactTopExp</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-810"></span><span>
</span><span id="line-811"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopLog"><span class="hs-identifier hs-type">interactTopLog</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-812"></span><span id="interactTopLog"><span class="annot"><span class="annottext">interactTopLog :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopLog"><span class="hs-identifier hs-var hs-var">interactTopLog</span></a></span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>   </span><span class="hs-comment">-- I can't think of anything...</span><span>
</span><span id="line-813"></span><span>
</span><span id="line-814"></span><span>
</span><span id="line-815"></span><span>
</span><span id="line-816"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopLeq"><span class="hs-identifier hs-type">interactTopLeq</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-817"></span><span id="interactTopLeq"><span class="annot"><span class="annottext">interactTopLeq :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopLeq"><span class="hs-identifier hs-var hs-var">interactTopLeq</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972616"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972616"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972615"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972615"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972614"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972614"><span class="hs-identifier hs-var">r</span></a></span></span><span>
</span><span id="line-818"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
</span><a href="#local-6989586621680972613"><span class="hs-identifier hs-var">mbY</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe Bool
</span><a href="#local-6989586621680972612"><span class="hs-identifier hs-var">mbZ</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972616"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#num"><span class="hs-identifier hs-var">num</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-special">]</span><span>                     </span><span class="hs-comment">-- (s &lt;= 0) =&gt; (s ~ 0)</span><span>
</span><span id="line-819"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-820"></span><span>  </span><span id="local-6989586621680972613"><span class="annot"><span class="annottext">mbY :: Maybe Integer
</span><a href="#local-6989586621680972613"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Integer
</span><a href="GHC.Core.Type.html#isNumLitTy"><span class="hs-identifier hs-var">isNumLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972615"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-821"></span><span>  </span><span id="local-6989586621680972612"><span class="annot"><span class="annottext">mbZ :: Maybe Bool
</span><a href="#local-6989586621680972612"><span class="hs-identifier hs-var hs-var">mbZ</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Bool
</span><a href="GHC.Builtin.Types.Literals.html#isBoolLitTy"><span class="hs-identifier hs-var">isBoolLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972614"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-822"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopLeq"><span class="hs-identifier hs-var">interactTopLeq</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-823"></span><span>
</span><span id="line-824"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopCmpNat"><span class="hs-identifier hs-type">interactTopCmpNat</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-825"></span><span id="interactTopCmpNat"><span class="annot"><span class="annottext">interactTopCmpNat :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopCmpNat"><span class="hs-identifier hs-var hs-var">interactTopCmpNat</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972611"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972611"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972610"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972610"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972609"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972609"><span class="hs-identifier hs-var">r</span></a></span></span><span>
</span><span id="line-826"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">EQ</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Ordering
</span><a href="GHC.Builtin.Types.Literals.html#isOrderingLitTy"><span class="hs-identifier hs-var">isOrderingLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972609"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972611"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972610"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-827"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopCmpNat"><span class="hs-identifier hs-var">interactTopCmpNat</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-828"></span><span>
</span><span id="line-829"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopCmpSymbol"><span class="hs-identifier hs-type">interactTopCmpSymbol</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-830"></span><span id="interactTopCmpSymbol"><span class="annot"><span class="annottext">interactTopCmpSymbol :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopCmpSymbol"><span class="hs-identifier hs-var hs-var">interactTopCmpSymbol</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972608"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972608"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972607"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972607"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972606"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972606"><span class="hs-identifier hs-var">r</span></a></span></span><span>
</span><span id="line-831"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">EQ</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Ordering
</span><a href="GHC.Builtin.Types.Literals.html#isOrderingLitTy"><span class="hs-identifier hs-var">isOrderingLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972606"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972608"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972607"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-832"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopCmpSymbol"><span class="hs-identifier hs-var">interactTopCmpSymbol</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-833"></span><span>
</span><span id="line-834"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopAppendSymbol"><span class="hs-identifier hs-type">interactTopAppendSymbol</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-835"></span><span id="interactTopAppendSymbol"><span class="annot"><span class="annottext">interactTopAppendSymbol :: [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactTopAppendSymbol"><span class="hs-identifier hs-var hs-var">interactTopAppendSymbol</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972605"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972605"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972604"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972604"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972603"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972603"><span class="hs-identifier hs-var">r</span></a></span></span><span>
</span><span id="line-836"></span><span>  </span><span class="hs-comment">-- (AppendSymbol a b ~ &quot;&quot;) =&gt; (a ~ &quot;&quot;, b ~ &quot;&quot;)</span><span>
</span><span id="line-837"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972602"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972602"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe FastString
</span><a href="#local-6989586621680972601"><span class="hs-identifier hs-var">mbZ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">FastString -&gt; Bool
</span><a href="GHC.Data.FastString.html#nullFS"><span class="hs-identifier hs-var">nullFS</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680972602"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-838"></span><span>    </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972605"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">FastString -&gt; Type
</span><a href="GHC.Core.Type.html#mkStrLitTy"><span class="hs-identifier hs-var">mkStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="GHC.Data.FastString.html#nilFS"><span class="hs-identifier hs-var">nilFS</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972604"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">FastString -&gt; Type
</span><a href="GHC.Core.Type.html#mkStrLitTy"><span class="hs-identifier hs-var">mkStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="GHC.Data.FastString.html#nilFS"><span class="hs-identifier hs-var">nilFS</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-839"></span><span>
</span><span id="line-840"></span><span>  </span><span class="hs-comment">-- (AppendSymbol &quot;foo&quot; b ~ &quot;foobar&quot;) =&gt; (b ~ &quot;bar&quot;)</span><span>
</span><span id="line-841"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972600"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972600"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(FastString -&gt; String) -&gt; Maybe FastString -&gt; Maybe String
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">FastString -&gt; String
</span><a href="GHC.Data.FastString.html#unpackFS"><span class="hs-identifier hs-var">unpackFS</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe FastString
</span><a href="#local-6989586621680972598"><span class="hs-identifier hs-var">mbX</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972597"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972597"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(FastString -&gt; String) -&gt; Maybe FastString -&gt; Maybe String
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">FastString -&gt; String
</span><a href="GHC.Data.FastString.html#unpackFS"><span class="hs-identifier hs-var">unpackFS</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe FastString
</span><a href="#local-6989586621680972601"><span class="hs-identifier hs-var">mbZ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972600"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; [a] -&gt; [a] -&gt; Bool
</span><a href="../../base/src/Data.OldList.html#isPrefixOf"><span class="hs-operator hs-var">`isPrefixOf`</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972597"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-842"></span><span>    </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972604"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">FastString -&gt; Type
</span><a href="GHC.Core.Type.html#mkStrLitTy"><span class="hs-identifier hs-var">mkStrLitTy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#mkFastString"><span class="hs-identifier hs-var">mkFastString</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; FastString) -&gt; String -&gt; FastString
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; String -&gt; String
forall a. Int -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#drop"><span class="hs-identifier hs-var">drop</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972600"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972597"><span class="hs-identifier hs-var">z</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-843"></span><span>
</span><span id="line-844"></span><span>  </span><span class="hs-comment">-- (AppendSymbol f &quot;bar&quot; ~ &quot;foobar&quot;) =&gt; (f ~ &quot;foo&quot;)</span><span>
</span><span id="line-845"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972593"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972593"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(FastString -&gt; String) -&gt; Maybe FastString -&gt; Maybe String
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">FastString -&gt; String
</span><a href="GHC.Data.FastString.html#unpackFS"><span class="hs-identifier hs-var">unpackFS</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe FastString
</span><a href="#local-6989586621680972592"><span class="hs-identifier hs-var">mbY</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680972591"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972591"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(FastString -&gt; String) -&gt; Maybe FastString -&gt; Maybe String
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">FastString -&gt; String
</span><a href="GHC.Data.FastString.html#unpackFS"><span class="hs-identifier hs-var">unpackFS</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe FastString
</span><a href="#local-6989586621680972601"><span class="hs-identifier hs-var">mbZ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972593"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; [a] -&gt; [a] -&gt; Bool
</span><a href="../../base/src/Data.OldList.html#isSuffixOf"><span class="hs-operator hs-var">`isSuffixOf`</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972591"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-846"></span><span>    </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972604"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">FastString -&gt; Type
</span><a href="GHC.Core.Type.html#mkStrLitTy"><span class="hs-identifier hs-var">mkStrLitTy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; FastString
</span><a href="GHC.Data.FastString.html#mkFastString"><span class="hs-identifier hs-var">mkFastString</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; FastString) -&gt; String -&gt; FastString
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; String -&gt; String
forall a. Int -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#take"><span class="hs-identifier hs-var">take</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972591"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972593"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680972591"><span class="hs-identifier hs-var">z</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-847"></span><span>
</span><span id="line-848"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-849"></span><span>  </span><span id="local-6989586621680972598"><span class="annot"><span class="annottext">mbX :: Maybe FastString
</span><a href="#local-6989586621680972598"><span class="hs-identifier hs-var hs-var">mbX</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe FastString
</span><a href="GHC.Core.Type.html#isStrLitTy"><span class="hs-identifier hs-var">isStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972605"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-850"></span><span>  </span><span id="local-6989586621680972592"><span class="annot"><span class="annottext">mbY :: Maybe FastString
</span><a href="#local-6989586621680972592"><span class="hs-identifier hs-var hs-var">mbY</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe FastString
</span><a href="GHC.Core.Type.html#isStrLitTy"><span class="hs-identifier hs-var">isStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972604"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-851"></span><span>  </span><span id="local-6989586621680972601"><span class="annot"><span class="annottext">mbZ :: Maybe FastString
</span><a href="#local-6989586621680972601"><span class="hs-identifier hs-var hs-var">mbZ</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe FastString
</span><a href="GHC.Core.Type.html#isStrLitTy"><span class="hs-identifier hs-var">isStrLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972603"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-852"></span><span>
</span><span id="line-853"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactTopAppendSymbol"><span class="hs-identifier hs-var">interactTopAppendSymbol</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-854"></span><span>
</span><span id="line-855"></span><span class="hs-comment">{-------------------------------------------------------------------------------
Interaction with inerts
-------------------------------------------------------------------------------}</span><span>
</span><span id="line-858"></span><span>
</span><span id="line-859"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertAdd"><span class="hs-identifier hs-type">interactInertAdd</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-860"></span><span id="interactInertAdd"><span class="annot"><span class="annottext">interactInertAdd :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertAdd"><span class="hs-identifier hs-var hs-var">interactInertAdd</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972589"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972589"><span class="hs-identifier hs-var">x1</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972588"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972588"><span class="hs-identifier hs-var">y1</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972587"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972587"><span class="hs-identifier hs-var">z1</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972586"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972586"><span class="hs-identifier hs-var">x2</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972585"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972585"><span class="hs-identifier hs-var">y2</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972584"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972584"><span class="hs-identifier hs-var">z2</span></a></span></span><span>
</span><span id="line-861"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972583"><span class="hs-identifier hs-var">sameZ</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972589"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972586"><span class="hs-identifier hs-var">x2</span></a></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972588"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972585"><span class="hs-identifier hs-var">y2</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-862"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972583"><span class="hs-identifier hs-var">sameZ</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972588"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972585"><span class="hs-identifier hs-var">y2</span></a></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972589"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972586"><span class="hs-identifier hs-var">x2</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-863"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972583"><span class="annot"><span class="annottext">sameZ :: Bool
</span><a href="#local-6989586621680972583"><span class="hs-identifier hs-var hs-var">sameZ</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972587"><span class="hs-identifier hs-var">z1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972584"><span class="hs-identifier hs-var">z2</span></a></span><span>
</span><span id="line-864"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertAdd"><span class="hs-identifier hs-var">interactInertAdd</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-865"></span><span>
</span><span id="line-866"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertSub"><span class="hs-identifier hs-type">interactInertSub</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-867"></span><span id="interactInertSub"><span class="annot"><span class="annottext">interactInertSub :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertSub"><span class="hs-identifier hs-var hs-var">interactInertSub</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972580"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972580"><span class="hs-identifier hs-var">x1</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972579"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972579"><span class="hs-identifier hs-var">y1</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972578"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972578"><span class="hs-identifier hs-var">z1</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972577"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972577"><span class="hs-identifier hs-var">x2</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972576"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972576"><span class="hs-identifier hs-var">y2</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972575"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972575"><span class="hs-identifier hs-var">z2</span></a></span></span><span>
</span><span id="line-868"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972574"><span class="hs-identifier hs-var">sameZ</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972580"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972577"><span class="hs-identifier hs-var">x2</span></a></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972579"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972576"><span class="hs-identifier hs-var">y2</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-869"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972574"><span class="hs-identifier hs-var">sameZ</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972579"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972576"><span class="hs-identifier hs-var">y2</span></a></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972580"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972577"><span class="hs-identifier hs-var">x2</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-870"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972574"><span class="annot"><span class="annottext">sameZ :: Bool
</span><a href="#local-6989586621680972574"><span class="hs-identifier hs-var hs-var">sameZ</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972578"><span class="hs-identifier hs-var">z1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972575"><span class="hs-identifier hs-var">z2</span></a></span><span>
</span><span id="line-871"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertSub"><span class="hs-identifier hs-var">interactInertSub</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-872"></span><span>
</span><span id="line-873"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertMul"><span class="hs-identifier hs-type">interactInertMul</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-874"></span><span id="interactInertMul"><span class="annot"><span class="annottext">interactInertMul :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertMul"><span class="hs-identifier hs-var hs-var">interactInertMul</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972572"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972572"><span class="hs-identifier hs-var">x1</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972571"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972571"><span class="hs-identifier hs-var">y1</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972570"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972570"><span class="hs-identifier hs-var">z1</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972569"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972569"><span class="hs-identifier hs-var">x2</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972568"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972568"><span class="hs-identifier hs-var">y2</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972567"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972567"><span class="hs-identifier hs-var">z2</span></a></span></span><span>
</span><span id="line-875"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972566"><span class="hs-identifier hs-var">sameZ</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Bool) -&gt; Type -&gt; Bool
</span><a href="GHC.Builtin.Types.Literals.html#known"><span class="hs-identifier hs-var">known</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972572"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972572"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972569"><span class="hs-identifier hs-var">x2</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972571"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972568"><span class="hs-identifier hs-var">y2</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-876"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972566"><span class="hs-identifier hs-var">sameZ</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Bool) -&gt; Type -&gt; Bool
</span><a href="GHC.Builtin.Types.Literals.html#known"><span class="hs-identifier hs-var">known</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972571"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972571"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972568"><span class="hs-identifier hs-var">y2</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972572"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972569"><span class="hs-identifier hs-var">x2</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-877"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972566"><span class="annot"><span class="annottext">sameZ :: Bool
</span><a href="#local-6989586621680972566"><span class="hs-identifier hs-var hs-var">sameZ</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972570"><span class="hs-identifier hs-var">z1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972567"><span class="hs-identifier hs-var">z2</span></a></span><span>
</span><span id="line-878"></span><span>
</span><span id="line-879"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertMul"><span class="hs-identifier hs-var">interactInertMul</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-880"></span><span>
</span><span id="line-881"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertDiv"><span class="hs-identifier hs-type">interactInertDiv</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-882"></span><span id="interactInertDiv"><span class="annot"><span class="annottext">interactInertDiv :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertDiv"><span class="hs-identifier hs-var hs-var">interactInertDiv</span></a></span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-883"></span><span>
</span><span id="line-884"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertMod"><span class="hs-identifier hs-type">interactInertMod</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-885"></span><span id="interactInertMod"><span class="annot"><span class="annottext">interactInertMod :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertMod"><span class="hs-identifier hs-var hs-var">interactInertMod</span></a></span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-886"></span><span>
</span><span id="line-887"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertExp"><span class="hs-identifier hs-type">interactInertExp</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-888"></span><span id="interactInertExp"><span class="annot"><span class="annottext">interactInertExp :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertExp"><span class="hs-identifier hs-var hs-var">interactInertExp</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972564"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972564"><span class="hs-identifier hs-var">x1</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972563"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972563"><span class="hs-identifier hs-var">y1</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972562"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972562"><span class="hs-identifier hs-var">z1</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972561"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972561"><span class="hs-identifier hs-var">x2</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972560"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972560"><span class="hs-identifier hs-var">y2</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972559"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972559"><span class="hs-identifier hs-var">z2</span></a></span></span><span>
</span><span id="line-889"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972558"><span class="hs-identifier hs-var">sameZ</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Bool) -&gt; Type -&gt; Bool
</span><a href="GHC.Builtin.Types.Literals.html#known"><span class="hs-identifier hs-var">known</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972564"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972564"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972561"><span class="hs-identifier hs-var">x2</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972563"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972560"><span class="hs-identifier hs-var">y2</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-890"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972558"><span class="hs-identifier hs-var">sameZ</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Bool) -&gt; Type -&gt; Bool
</span><a href="GHC.Builtin.Types.Literals.html#known"><span class="hs-identifier hs-var">known</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972563"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972563"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972560"><span class="hs-identifier hs-var">y2</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972564"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972561"><span class="hs-identifier hs-var">x2</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-891"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972558"><span class="annot"><span class="annottext">sameZ :: Bool
</span><a href="#local-6989586621680972558"><span class="hs-identifier hs-var hs-var">sameZ</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972562"><span class="hs-identifier hs-var">z1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972559"><span class="hs-identifier hs-var">z2</span></a></span><span>
</span><span id="line-892"></span><span>
</span><span id="line-893"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertExp"><span class="hs-identifier hs-var">interactInertExp</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-894"></span><span>
</span><span id="line-895"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertLog"><span class="hs-identifier hs-type">interactInertLog</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-896"></span><span id="interactInertLog"><span class="annot"><span class="annottext">interactInertLog :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertLog"><span class="hs-identifier hs-var hs-var">interactInertLog</span></a></span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-897"></span><span>
</span><span id="line-898"></span><span>
</span><span id="line-899"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertLeq"><span class="hs-identifier hs-type">interactInertLeq</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-900"></span><span id="interactInertLeq"><span class="annot"><span class="annottext">interactInertLeq :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertLeq"><span class="hs-identifier hs-var hs-var">interactInertLeq</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972555"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972555"><span class="hs-identifier hs-var">x1</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972554"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972554"><span class="hs-identifier hs-var">y1</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972553"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972553"><span class="hs-identifier hs-var">z1</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972552"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972552"><span class="hs-identifier hs-var">x2</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972551"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972551"><span class="hs-identifier hs-var">y2</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972550"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972550"><span class="hs-identifier hs-var">z2</span></a></span></span><span>
</span><span id="line-901"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972549"><span class="hs-identifier hs-var">bothTrue</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972555"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972551"><span class="hs-identifier hs-var">y2</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972554"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972552"><span class="hs-identifier hs-var">x2</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972555"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972554"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-902"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972549"><span class="hs-identifier hs-var">bothTrue</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972554"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972552"><span class="hs-identifier hs-var">x2</span></a></span><span>                 </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972555"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#%3C%3D%3D"><span class="hs-operator hs-var">&lt;==</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972551"><span class="hs-identifier hs-var">y2</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#bool"><span class="hs-identifier hs-var">bool</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-903"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972549"><span class="hs-identifier hs-var">bothTrue</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972551"><span class="hs-identifier hs-var">y2</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972555"><span class="hs-identifier hs-var">x1</span></a></span><span>                 </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972552"><span class="hs-identifier hs-var">x2</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#%3C%3D%3D"><span class="hs-operator hs-var">&lt;==</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972554"><span class="hs-identifier hs-var">y1</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Type
</span><a href="GHC.Builtin.Types.Literals.html#bool"><span class="hs-identifier hs-var">bool</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-904"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972549"><span class="annot"><span class="annottext">bothTrue :: Bool
</span><a href="#local-6989586621680972549"><span class="hs-identifier hs-var hs-var">bothTrue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe () -&gt; Bool
forall a. Maybe a -&gt; Bool
</span><a href="../../base/src/Data.Maybe.html#isJust"><span class="hs-identifier hs-var">isJust</span></a></span><span> </span><span class="annot"><span class="annottext">(Maybe () -&gt; Bool) -&gt; Maybe () -&gt; Bool
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Bool
</span><a href="GHC.Builtin.Types.Literals.html#isBoolLitTy"><span class="hs-identifier hs-var">isBoolLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972553"><span class="hs-identifier hs-var">z1</span></a></span><span>
</span><span id="line-905"></span><span>                               </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Maybe Bool
</span><a href="GHC.Builtin.Types.Literals.html#isBoolLitTy"><span class="hs-identifier hs-var">isBoolLitTy</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972550"><span class="hs-identifier hs-var">z2</span></a></span><span>
</span><span id="line-906"></span><span>                               </span><span class="annot"><span class="annottext">() -&gt; Maybe ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-907"></span><span>
</span><span id="line-908"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertLeq"><span class="hs-identifier hs-var">interactInertLeq</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-909"></span><span>
</span><span id="line-910"></span><span>
</span><span id="line-911"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertAppendSymbol"><span class="hs-identifier hs-type">interactInertAppendSymbol</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Tc.Types.Constraint.html#Xi"><span class="hs-identifier hs-type">Xi</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Data.Pair.html#Pair"><span class="hs-identifier hs-type">Pair</span></a></span><span> </span><span class="annot"><a href="GHC.Core.TyCo.Rep.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-912"></span><span id="interactInertAppendSymbol"><span class="annot"><span class="annottext">interactInertAppendSymbol :: [Type] -&gt; Type -&gt; [Type] -&gt; Type -&gt; [TypeEqn]
</span><a href="GHC.Builtin.Types.Literals.html#interactInertAppendSymbol"><span class="hs-identifier hs-var hs-var">interactInertAppendSymbol</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972543"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972543"><span class="hs-identifier hs-var">x1</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972542"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972542"><span class="hs-identifier hs-var">y1</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972541"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972541"><span class="hs-identifier hs-var">z1</span></a></span></span><span> </span><span class="hs-special">[</span><span id="local-6989586621680972540"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972540"><span class="hs-identifier hs-var">x2</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972539"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972539"><span class="hs-identifier hs-var">y2</span></a></span></span><span class="hs-special">]</span><span> </span><span id="local-6989586621680972538"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972538"><span class="hs-identifier hs-var">z2</span></a></span></span><span>
</span><span id="line-913"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972537"><span class="hs-identifier hs-var">sameZ</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972543"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972540"><span class="hs-identifier hs-var">x2</span></a></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972542"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972539"><span class="hs-identifier hs-var">y2</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-914"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680972537"><span class="hs-identifier hs-var">sameZ</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972542"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972539"><span class="hs-identifier hs-var">y2</span></a></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972543"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; TypeEqn
</span><a href="GHC.Builtin.Types.Literals.html#%3D%3D%3D"><span class="hs-operator hs-var">===</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972540"><span class="hs-identifier hs-var">x2</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-915"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680972537"><span class="annot"><span class="annottext">sameZ :: Bool
</span><a href="#local-6989586621680972537"><span class="hs-identifier hs-var hs-var">sameZ</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">HasDebugCallStack =&gt; Type -&gt; Type -&gt; Bool
Type -&gt; Type -&gt; Bool
</span><a href="GHC.Tc.Utils.TcType.html#tcEqType"><span class="hs-identifier hs-var">tcEqType</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972541"><span class="hs-identifier hs-var">z1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621680972538"><span class="hs-identifier hs-var">z2</span></a></span><span>
</span><span id="line-916"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#interactInertAppendSymbol"><span class="hs-identifier hs-var">interactInertAppendSymbol</span></a></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[Type]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Type
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-917"></span><span>
</span><span id="line-918"></span><span>
</span><span id="line-919"></span><span>
</span><span id="line-920"></span><span class="hs-comment">{- -----------------------------------------------------------------------------
These inverse functions are used for simplifying propositions using
concrete natural numbers.
----------------------------------------------------------------------------- -}</span><span>
</span><span id="line-924"></span><span>
</span><span id="line-925"></span><span class="hs-comment">-- | Subtract two natural numbers.</span><span>
</span><span id="line-926"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#minus"><span class="hs-identifier hs-type">minus</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span>
</span><span id="line-927"></span><span id="minus"><span class="annot"><span class="annottext">minus :: Integer -&gt; Integer -&gt; Maybe Integer
</span><a href="GHC.Builtin.Types.Literals.html#minus"><span class="hs-identifier hs-var hs-var">minus</span></a></span></span><span> </span><span id="local-6989586621680972535"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972535"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972534"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972534"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972535"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972534"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Maybe Integer
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972535"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972534"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-928"></span><span>
</span><span id="line-929"></span><span class="hs-comment">-- | Compute the exact logarithm of a natural number.</span><span>
</span><span id="line-930"></span><span class="hs-comment">-- The logarithm base is the second argument.</span><span>
</span><span id="line-931"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#logExact"><span class="hs-identifier hs-type">logExact</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span>
</span><span id="line-932"></span><span id="logExact"><span class="annot"><span class="annottext">logExact :: Integer -&gt; Integer -&gt; Maybe Integer
</span><a href="GHC.Builtin.Types.Literals.html#logExact"><span class="hs-identifier hs-var hs-var">logExact</span></a></span></span><span> </span><span id="local-6989586621680972533"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972533"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972532"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972532"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">(</span><span id="local-6989586621680972531"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972531"><span class="hs-identifier hs-var">z</span></a></span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe (Integer, Bool)
</span><a href="GHC.Builtin.Types.Literals.html#genLog"><span class="hs-identifier hs-var">genLog</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972533"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972532"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-933"></span><span>                  </span><span class="annot"><span class="annottext">Integer -&gt; Maybe Integer
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972531"><span class="hs-identifier hs-var">z</span></a></span><span>
</span><span id="line-934"></span><span>
</span><span id="line-935"></span><span>
</span><span id="line-936"></span><span class="hs-comment">-- | Divide two natural numbers.</span><span>
</span><span id="line-937"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#divide"><span class="hs-identifier hs-type">divide</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span>
</span><span id="line-938"></span><span id="divide"><span class="annot"><span class="annottext">divide :: Integer -&gt; Integer -&gt; Maybe Integer
</span><a href="GHC.Builtin.Types.Literals.html#divide"><span class="hs-identifier hs-var hs-var">divide</span></a></span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-939"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#divide"><span class="hs-identifier hs-var">divide</span></a></span><span> </span><span id="local-6989586621680972530"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972530"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972529"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972529"><span class="hs-identifier hs-var">y</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; (Integer, Integer)
forall a. Integral a =&gt; a -&gt; a -&gt; (a, a)
</span><a href="../../base/src/GHC.Real.html#divMod"><span class="hs-identifier hs-var">divMod</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972530"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972529"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-940"></span><span>                </span><span class="hs-special">(</span><span id="local-6989586621680972527"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972527"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Maybe Integer
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972527"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-941"></span><span>                </span><span class="annot"><span class="annottext">(Integer, Integer)
</span><span class="hs-identifier">_</span></span><span>     </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Maybe Integer
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-942"></span><span>
</span><span id="line-943"></span><span class="hs-comment">-- | Compute the exact root of a natural number.</span><span>
</span><span id="line-944"></span><span class="hs-comment">-- The second argument specifies which root we are computing.</span><span>
</span><span id="line-945"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#rootExact"><span class="hs-identifier hs-type">rootExact</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span>
</span><span id="line-946"></span><span id="rootExact"><span class="annot"><span class="annottext">rootExact :: Integer -&gt; Integer -&gt; Maybe Integer
</span><a href="GHC.Builtin.Types.Literals.html#rootExact"><span class="hs-identifier hs-var hs-var">rootExact</span></a></span></span><span> </span><span id="local-6989586621680972526"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972526"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972525"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972525"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">(</span><span id="local-6989586621680972524"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972524"><span class="hs-identifier hs-var">z</span></a></span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Maybe (Integer, Bool)
</span><a href="GHC.Builtin.Types.Literals.html#genRoot"><span class="hs-identifier hs-var">genRoot</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972526"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972525"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-947"></span><span>                   </span><span class="annot"><span class="annottext">Integer -&gt; Maybe Integer
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972524"><span class="hs-identifier hs-var">z</span></a></span><span>
</span><span id="line-948"></span><span>
</span><span id="line-949"></span><span>
</span><span id="line-950"></span><span>
</span><span id="line-951"></span><span class="hs-comment">{- | Compute the n-th root of a natural number, rounded down to
the closest natural number.  The boolean indicates if the result
is exact (i.e., True means no rounding was done, False means rounded down).
The second argument specifies which root we are computing. -}</span><span>
</span><span id="line-955"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#genRoot"><span class="hs-identifier hs-type">genRoot</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span class="hs-special">)</span><span>
</span><span id="line-956"></span><span id="genRoot"><span class="annot"><span class="annottext">genRoot :: Integer -&gt; Integer -&gt; Maybe (Integer, Bool)
</span><a href="GHC.Builtin.Types.Literals.html#genRoot"><span class="hs-identifier hs-var hs-var">genRoot</span></a></span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-identifier">_</span></span><span>  </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (Integer, Bool)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-957"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#genRoot"><span class="hs-identifier hs-var">genRoot</span></a></span><span> </span><span id="local-6989586621680972522"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972522"><span class="hs-identifier hs-var">x0</span></a></span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Integer, Bool) -&gt; Maybe (Integer, Bool)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972522"><span class="hs-identifier hs-var">x0</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-special">)</span><span>
</span><span id="line-958"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#genRoot"><span class="hs-identifier hs-var">genRoot</span></a></span><span> </span><span id="local-6989586621680972521"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972521"><span class="hs-identifier hs-var">x0</span></a></span></span><span> </span><span id="local-6989586621680972520"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972520"><span class="hs-identifier hs-var">root</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Integer, Bool) -&gt; Maybe (Integer, Bool)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; (Integer, Bool)
</span><a href="#local-6989586621680972519"><span class="hs-identifier hs-var">search</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972521"><span class="hs-identifier hs-var">x0</span></a></span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-959"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-960"></span><span>  </span><span id="local-6989586621680972519"><span class="annot"><span class="annottext">search :: Integer -&gt; Integer -&gt; (Integer, Bool)
</span><a href="#local-6989586621680972519"><span class="hs-identifier hs-var hs-var">search</span></a></span></span><span> </span><span id="local-6989586621680972515"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972515"><span class="hs-identifier hs-var">from</span></a></span></span><span> </span><span id="local-6989586621680972514"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972514"><span class="hs-identifier hs-var">to</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680972509"><span class="annot"><span class="annottext">x :: Integer
</span><a href="#local-6989586621680972509"><span class="hs-identifier hs-var hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972515"><span class="hs-identifier hs-var">from</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#div"><span class="hs-identifier hs-var">div</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972514"><span class="hs-identifier hs-var">to</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972515"><span class="hs-identifier hs-var">from</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">2</span></span><span>
</span><span id="line-961"></span><span>                       </span><span id="local-6989586621680972506"><span class="annot"><span class="annottext">a :: Integer
</span><a href="#local-6989586621680972506"><span class="hs-identifier hs-var hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972509"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a b. (Num a, Integral b) =&gt; a -&gt; b -&gt; a
</span><a href="../../base/src/GHC.Real.html#%5E"><span class="hs-operator hs-var">^</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972520"><span class="hs-identifier hs-var">root</span></a></span><span>
</span><span id="line-962"></span><span>                   </span><span class="hs-keyword">in</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><span class="hs-identifier hs-var">compare</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972506"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972521"><span class="hs-identifier hs-var">x0</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-963"></span><span>                        </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">EQ</span></span><span>              </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972509"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-special">)</span><span>
</span><span id="line-964"></span><span>                        </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">LT</span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972509"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972515"><span class="hs-identifier hs-var">from</span></a></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; (Integer, Bool)
</span><a href="#local-6989586621680972519"><span class="hs-identifier hs-var">search</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972509"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972514"><span class="hs-identifier hs-var">to</span></a></span><span>
</span><span id="line-965"></span><span>                           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972515"><span class="hs-identifier hs-var">from</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span class="hs-special">)</span><span>
</span><span id="line-966"></span><span>                        </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">GT</span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972509"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972514"><span class="hs-identifier hs-var">to</span></a></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; (Integer, Bool)
</span><a href="#local-6989586621680972519"><span class="hs-identifier hs-var">search</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972515"><span class="hs-identifier hs-var">from</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972509"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-967"></span><span>                           </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972515"><span class="hs-identifier hs-var">from</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span class="hs-special">)</span><span>
</span><span id="line-968"></span><span>
</span><span id="line-969"></span><span class="hs-comment">{- | Compute the logarithm of a number in the given base, rounded down to the
closest integer.  The boolean indicates if we the result is exact
(i.e., True means no rounding happened, False means we rounded down).
The logarithm base is the second argument. -}</span><span>
</span><span id="line-973"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#genLog"><span class="hs-identifier hs-type">genLog</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span class="hs-special">)</span><span>
</span><span id="line-974"></span><span id="genLog"><span class="annot"><span class="annottext">genLog :: Integer -&gt; Integer -&gt; Maybe (Integer, Bool)
</span><a href="GHC.Builtin.Types.Literals.html#genLog"><span class="hs-identifier hs-var hs-var">genLog</span></a></span></span><span> </span><span id="local-6989586621680972505"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972505"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972505"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">(Integer, Bool) -&gt; Maybe (Integer, Bool)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">Maybe (Integer, Bool)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-975"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#genLog"><span class="hs-identifier hs-var">genLog</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (Integer, Bool)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-976"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#genLog"><span class="hs-identifier hs-var">genLog</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-identifier">_</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (Integer, Bool)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-977"></span><span class="annot"><a href="GHC.Builtin.Types.Literals.html#genLog"><span class="hs-identifier hs-var">genLog</span></a></span><span> </span><span id="local-6989586621680972504"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972504"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621680972503"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972503"><span class="hs-identifier hs-var">base</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Integer, Bool) -&gt; Maybe (Integer, Bool)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; (Integer, Bool)
forall {a}. Num a =&gt; a -&gt; Integer -&gt; (a, Bool)
</span><a href="#local-6989586621680972502"><span class="hs-identifier hs-var">exactLoop</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972504"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-978"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-979"></span><span>  </span><span id="local-6989586621680972502"><span class="annot"><span class="annottext">exactLoop :: a -&gt; Integer -&gt; (a, Bool)
</span><a href="#local-6989586621680972502"><span class="hs-identifier hs-var hs-var">exactLoop</span></a></span></span><span> </span><span id="local-6989586621680972493"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680972493"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972492"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972492"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-980"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972492"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">1</span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680972493"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-special">)</span><span>
</span><span id="line-981"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972492"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972503"><span class="hs-identifier hs-var">base</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680972493"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span class="hs-special">)</span><span>
</span><span id="line-982"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>  </span><span class="hs-glyph">=</span><span>
</span><span id="line-983"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680972488"><span class="annot"><span class="annottext">s1 :: a
</span><a href="#local-6989586621680972488"><span class="hs-identifier hs-var hs-var">s1</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680972493"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">1</span></span><span>
</span><span id="line-984"></span><span>        </span><span class="hs-keyword">in</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680972488"><span class="hs-identifier hs-var">s1</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; (a, Bool) -&gt; (a, Bool)
</span><span class="hs-operator hs-var">`seq`</span></span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; (Integer, Integer)
forall a. Integral a =&gt; a -&gt; a -&gt; (a, a)
</span><a href="../../base/src/GHC.Real.html#divMod"><span class="hs-identifier hs-var">divMod</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972492"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972503"><span class="hs-identifier hs-var">base</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-985"></span><span>                      </span><span class="hs-special">(</span><span id="local-6989586621680972487"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972487"><span class="hs-identifier hs-var">j</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680972486"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972486"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span>
</span><span id="line-986"></span><span>                        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972486"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">a -&gt; Integer -&gt; (a, Bool)
</span><a href="#local-6989586621680972502"><span class="hs-identifier hs-var">exactLoop</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680972488"><span class="hs-identifier hs-var">s1</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972487"><span class="hs-identifier hs-var">j</span></a></span><span>
</span><span id="line-987"></span><span>                        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Integer -&gt; a
forall {t}. Num t =&gt; t -&gt; Integer -&gt; t
</span><a href="#local-6989586621680972485"><span class="hs-identifier hs-var">underLoop</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680972488"><span class="hs-identifier hs-var">s1</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972487"><span class="hs-identifier hs-var">j</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span class="hs-special">)</span><span>
</span><span id="line-988"></span><span>
</span><span id="line-989"></span><span>  </span><span id="local-6989586621680972485"><span class="annot"><span class="annottext">underLoop :: t -&gt; Integer -&gt; t
</span><a href="#local-6989586621680972485"><span class="hs-identifier hs-var hs-var">underLoop</span></a></span></span><span> </span><span id="local-6989586621680972481"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621680972481"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680972480"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972480"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-990"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972480"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972503"><span class="hs-identifier hs-var">base</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621680972481"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-991"></span><span>    </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680972477"><span class="annot"><span class="annottext">s1 :: t
</span><a href="#local-6989586621680972477"><span class="hs-identifier hs-var hs-var">s1</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621680972481"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">1</span></span><span> </span><span class="hs-keyword">in</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621680972477"><span class="hs-identifier hs-var">s1</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
</span><span class="hs-operator hs-var">`seq`</span></span><span> </span><span class="annot"><span class="annottext">t -&gt; Integer -&gt; t
</span><a href="#local-6989586621680972485"><span class="hs-identifier hs-var">underLoop</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621680972477"><span class="hs-identifier hs-var">s1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Integral a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Real.html#div"><span class="hs-identifier hs-var">div</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972480"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680972503"><span class="hs-identifier hs-var">base</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-992"></span></pre></body></html>